SP-19 Update Approach Using a Shared Library

[peterduhon]

Project Extraction: Updated Approach Using a Shared Library PRD1

Objective:

To refactor the existing codebase by extracting shared logic related to card management, hand evaluation, and pot management into a centralized shared library. This will ensure code reusability, consistency, and gas efficiency across multiple contracts and EVM blockchains.

Steps:

1. Create a Shared Library:

   • Name: CardLibrary
   • Purpose: Encapsulate all logic related to card management, hand evaluation, and utility functions that can be reused across contracts.
   • Functions to Include:
     • Struct definition for Card.
     • Hand evaluation functions (e.g., isPair, isFlush, isStraight, evaluateHand).
     • Utility functions for card comparison, deck management, and pot distribution.

   Example:

   library CardLibrary {
      struct Card {
          uint8 suit;
          uint8 value;
      }
   
      function isPair(Card[] memory hand) internal pure returns (bool) {
          // Implementation of pair checking logic
      }
   
      function evaluateHand(Card[] memory hand) internal pure returns (uint256) {
          // Implementation of hand evaluation logic
      }
   
      // Additional utility functions for card and deck management
   }

2. Refactor Existing Contracts:

   • Objective: Refactor the existing HandEvaluator, BettingAndPotManagement, and CardManagement contracts to use the shared library.
   • Steps:
     • Remove any duplicated logic that pertains to card management or hand evaluation from these contracts.
     • Import the CardLibrary in each contract and utilize its functions where needed.

   Example Refactor:

   import "./CardLibrary.sol";
   
   contract CardManagement {
      using CardLibrary for CardLibrary.Card[];
   
      function evaluateHand(CardLibrary.Card[] memory hand) internal pure returns (uint256) {
          return CardLibrary.evaluateHand(hand);
      }
   }

3. Deployment Strategy:

   • Deploy CardLibrary Once per Blockchain:

     • Deploy the CardLibrary to each target EVM blockchain.
     • Link the deployed library to the HandEvaluator, BettingAndPotManagement, and CardManagement contracts during their deployment.

   • Linking Libraries:

     • Ensure that each contract that depends on the shared library is correctly linked during the deployment process to avoid any runtime issues.

4. Testing and Validation:

   • Comprehensive Testing:

     • Develop comprehensive unit tests for the CardLibrary to validate the correctness of all shared functions.
     • Test the refactored contracts to ensure they function correctly with the library.
     • Pay special attention to gas costs to confirm that using the shared library reduces overall deployment and execution costs.

   • Deployment on Testnets:

     • Deploy the contracts on testnets to verify that the library is correctly linked and that cross-contract interactions work as expected.

5. Documentation and Knowledge Transfer:

   • Update Documentation:

     • Provide detailed documentation for the shared library, including function descriptions, usage examples, and guidelines for future updates.
     • Document the deployment and linking process to ensure clarity for future deployments on additional blockchains.

   • Knowledge Sharing:

     • Conduct a session with the team to explain the changes, the reasoning behind using a shared library, and the process for deploying and linking the library on multiple blockchains.

6. Rollout Plan for Additional Blockchains:

   • Scalable Deployment:

     Future State - Post-Hackathon

     - Once the shared library and refactored contracts are validated on the initial blockchains, create a plan for rolling out the solution to additional EVM-compatible blockchains.

     • Ensure that the deployment scripts are flexible enough to accommodate the deployment of the library and contracts across multiple blockchains efficiently.##

Conclusion:

This updated approach to Project Extraction leverages the benefits of a shared library to streamline code management, reduce gas costs, and ensure consistency across all contracts deployed on multiple EVM blockchains. By centralizing common logic, we enhance maintainability and simplify future updates, positioning the project for scalable growth as it expands to more blockchain environments.