ERC-7751: Wrapping of Bubbled Up Reverts

gretzke · October 7, 2024, 5:55pm

I implemented the updated ERC spec in Uniswap v4 here:

Uniswap/v4-core/blob/6526044abffee244cbf7e8ee66c04c8182ad34f0/src/libraries/CustomRevert.sol#L81-L109


      
          /// @notice bubble up the revert message returned by a call and revert with a wrapped ERC-7751 error
          function bubbleUpAndRevertWith(address target, bytes4 functionSelector, bytes4 additionalContext) internal pure {
              bytes4 wrappedErrorSelector = WrappedError.selector;
              assembly ("memory-safe") {
                  let size := returndatasize()
                  // Ensure the size of the revert data is a multiple of 32 bytes
                  let encodedDataSize := mul(div(add(size, 31), 32), 32)
          
                  let fmp := mload(0x40)
          
                  // Encode wrapped error selector, address, function selector, offset, additional context, size, revert reason
                  mstore(fmp, wrappedErrorSelector)
                  mstore(add(fmp, 0x04), target)
                  mstore(add(fmp, 0x24), functionSelector)
                  // offset revert reason
                  mstore(add(fmp, 0x44), 0x80)
                  // offset additional context
                  mstore(add(fmp, 0x64), add(0xa0, encodedDataSize))
                  // size revert reason
                  mstore(add(fmp, 0x84), size)

This file has been truncated. show original

It’s called when a hook call fails for example:

github.com

Uniswap/v4-core/blob/6526044abffee244cbf7e8ee66c04c8182ad34f0/src/libraries/Hooks.sol#L136


      
          }
          
          /// @notice performs a hook call using the given calldata on the given hook that doesnt return a delta
          /// @return result The complete data returned by the hook
          function callHook(IHooks self, bytes memory data) internal returns (bytes memory result) {
              bool success;
              assembly ("memory-safe") {
                  success := call(gas(), self, 0, add(data, 0x20), mload(data), 0, 0)
              }
              // Revert with FailedHookCall, containing any error message to bubble up
              if (!success) CustomRevert.bubbleUpAndRevertWith(address(self), bytes4(data), HookCallFailed.selector);
          
              // The call was successful, fetch the returned data
              assembly ("memory-safe") {
                  // allocate result byte array from the free memory pointer
                  result := mload(0x40)
                  // store new free memory pointer at the end of the array padded to 32 bytes
                  mstore(0x40, add(result, and(add(returndatasize(), 0x3f), not(0x1f))))
                  // store length in memory
                  mstore(result, returndatasize())
                  // copy return data to result

Are there any additional concerns with the specification?