Weekly Development Updates (6/21/24)

[CodesMcCabe]

• Permission hooks added [2/n permissions] feat: add permission hooks reference-implementation#76
  • Permission hooks are hooks associated with a validation function. The proposed model of permissions is:
    1. A validation function, global or associated with a selector
    2. A set of pre validation functions associated with the validation function that will all run, and must all pass (AND logic)
    3. A set of permission hooks (pre and post execution) that applies to the validation. If the permission hook requires the UO context, the top level execution call must be made to executeUserOp, and the full PackedUserOp struct would be passed to the hook
• Enforce calls during UserOp validation are made to executeUserOp [3/n permissions] feat: add execute user operation reference-implementation#77
  • Useful if hooks require UserOp context
• Plugins that demonstrate permissions usage:
  • Native token spend limit [4/n permissions] feat: add native token spend limit plugin reference-implementation#79
  • ERC20 token spend limit [5/n permissions] feat: add erc20 token spend limit plugin reference-implementation#80
• Research: Self-call Validation
  • Self-Calls for Efficiency and Simplicity: Self-calls are essential for efficiency in executing user operations, as they avoid the need for both internal and external access for every function, simplifying the implementation and reducing gas costs.
  • Embedding Self-Calls into Standards: While not initially required in the spec, self-calls are necessary for certain runtime validators to function correctly, making it logical to embed this behavior into the standard.
  • Necessity for Specific Workflows: Self-calls are necessary for specific workflows, such as those involving executeUserOp, where access to user operation fields is required without redundant validations.
  • Bytecode Efficiency: Using self-calls can lead to more efficient bytecode usage since it avoids the need for multiple external calls and validation layers, reducing the overall complexity of the contract's bytecode.
  • Challenges with Pre-Validation Hooks: Implementing pre-validation hooks for self-calls poses challenges, as these hooks need to decode the call tree to validate specific selectors, complicating the implementation.
  • Batch Operations: Self-calls are used in batching operations, where multiple internal calls are executed together, making processes like installing plugins and sending tokens more efficient through functions like executeBatch.
  • Permission Handling: Self-calls help manage permissions by ensuring that internal functions can bypass certain checks that are only necessary for external calls, streamlining permission handling within the contract.