7914 detector (#36)

* 7914 detector

* Forge fmt

* Enable solidity optimizer

* Fix fuzz test bounds

* Test via_ir

* Remove test utils from forge build --sizes

* Add natspec header

* Add note about gas optimization

Author: codyborn

.github/workflows/test.yml

@@ -24,12 +24,12 @@ jobs:
       - name: Install Foundry
         uses: foundry-rs/foundry-toolchain@v1
         with:
-          version: nightly
+          version: v1.1.0
 
       - name: Run Forge build
         run: |
           forge --version
-          forge build --sizes
+          forge build --sizes | grep -v -E "(CaliburEntryUtils|Mock.*|BaseAuthorization)"
         id: build
 
       - name: Run Forge tests

src/ERC7914Detector.sol

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC7914} from "./interfaces/IERC7914.sol";
+
+/// @title ERC7914Detector
+/// @notice A utility contract for detecting ERC7914 support in wallet contracts
+/// @dev This contract provides functionality to check if a given address supports
+/// the ERC7914 standard, which enables native token transfers from smart contract
+/// wallets. It handles both regular contracts and EIP-7702 account abstraction wallets.
+///
+/// The contract works by:
+/// 1. Checking if the address is an EOA (Externally Owned Account) - EOAs cannot support ERC7914
+/// 2. For EIP-7702 wallets, checking if they delegate to a known ERC7914-compliant contract
+/// 3. For regular contracts, checking if they implement the transferFromNative function
+///
+/// Intended for offchain view calls. Not gas optimized.
+/// @custom:security-contact security@uniswap.org
+contract ERC7914Detector {
+    // EIP-7702 constants from account-abstraction library
+    bytes3 internal constant EIP7702_PREFIX = 0xef0100;
+
+    // EIP-7702 bytecode structure: 3 bytes prefix + 20 bytes delegate address = 23 bytes total
+    uint256 internal constant EIP7702_BYTECODE_SIZE = 23;
+
+    address public immutable caliburAddress;
+
+    constructor(address _caliburAddress) {
+        caliburAddress = _caliburAddress;
+    }
+
+    /**
+     * @notice Check if a wallet supports ERC7914 by testing for transferFromNative function
+     * @param wallet The wallet address to check
+     * @return hasERC7914Support true if ERC7914 is supported, false otherwise
+     */
+    function hasERC7914Support(address wallet) external view returns (bool) {
+        // EOAs cannot support ERC7914
+        uint256 codeSize;
+        assembly {
+            codeSize := extcodesize(wallet)
+        }
+        if (codeSize == 0) {
+            return false;
+        }
+
+        // Check if this is an EIP-7702 wallet delegating to Calibur
+        if (_isEip7702Delegate(wallet)) {
+            address delegate = _getEip7702Delegate(wallet);
+            // If it delegates to Calibur, it has ERC7914 support
+            if (delegate == caliburAddress) {
+                return true;
+            }
+            // If it delegates to another contract, check that contract
+            return _checkTransferFromNative(delegate);
+        }
+
+        // For regular contracts, check if transferFromNative function exists
+        return _checkTransferFromNative(wallet);
+    }
+
+    /**
+     * @notice Get the EIP-7702 bytecode from contract (prefix + delegate address)
+     * @param wallet The wallet address to read from
+     * @return code The first 23 bytes of bytecode (3 byte prefix + 20 byte delegate)
+     */
+    function _getContractCode(address wallet) private view returns (bytes32 code) {
+        assembly ("memory-safe") {
+            extcodecopy(wallet, 0, 0, EIP7702_BYTECODE_SIZE)
+            code := mload(0)
+        }
+    }
+
+    /**
+     * @notice Check if an address is an EIP-7702 wallet
+     * @param wallet The wallet address to check
+     * @return true if it's an EIP-7702 wallet, false otherwise
+     */
+    function _isEip7702Delegate(address wallet) private view returns (bool) {
+        if (wallet.code.length < EIP7702_BYTECODE_SIZE) return false;
+        return bytes3(_getContractCode(wallet)) == EIP7702_PREFIX;
+    }
+
+    /**
+     * @notice Get the delegate address from an EIP-7702 wallet
+     * @param wallet The EIP-7702 wallet address
+     * @return delegate The delegate contract address
+     */
+    function _getEip7702Delegate(address wallet) private view returns (address) {
+        bytes32 code = _getContractCode(wallet);
+        return address(bytes20(code << 24));
+    }
+
+    function _checkTransferFromNative(address wallet) private view returns (bool) {
+        // Check if the function selector exists by examining the contract bytecode
+        // Since transferFromNative requires authorization, we can't call it directly
+        bytes4 selector = IERC7914.transferFromNative.selector;
+
+        // Use low-level call to check if function exists
+        (bool success, bytes memory returnData) =
+            wallet.staticcall(abi.encodeWithSelector(selector, address(0), address(0), 0));
+
+        // If the call succeeded and returned a valid boolean, the function exists
+        if (success && returnData.length == 32) {
+            // Decode and verify it's a valid boolean (0 or 1)
+            uint256 returnValue = abi.decode(returnData, (uint256));
+            if (returnValue <= 1) {
+                return true;
+            }
+        }
+
+        // If the call succeeded but returned empty data, it hit the fallback
+        // This indicates the function doesn't exist
+        if (success && returnData.length == 0) {
+            return false;
+        }
+
+        return false; // Default to function not existing
+    }
+}

src/interfaces/ICalibur.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC7914} from "./IERC7914.sol";
+
+/// A non-upgradeable contract that can be delegated to with a 7702 delegation transaction.
+/// This implementation supports:
+/// ERC-7914 transfer from native
+interface ICalibur is IERC7914 {}

src/interfaces/IERC7914.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @title IERC7914
+interface IERC7914 {
+    /// @notice Thrown when the caller's allowance is exceeded when transferring
+    error AllowanceExceeded();
+    /// @notice Thrown when the sender is not the expected one
+    error IncorrectSender();
+    /// @notice Thrown when the transfer of native tokens fails
+    error TransferNativeFailed();
+
+    /// @notice Emitted when a transfer from native is made
+    event TransferFromNative(address indexed from, address indexed to, uint256 value);
+    /// @notice Emitted when a native approval is made
+    event ApproveNative(address indexed owner, address indexed spender, uint256 value);
+    /// @notice Emitted when a transfer from native transient is made
+    event TransferFromNativeTransient(address indexed from, address indexed to, uint256 value);
+    /// @notice Emitted when a transient native approval is made
+    event ApproveNativeTransient(address indexed owner, address indexed spender, uint256 value);
+    /// @notice Emitted when the native allowance of a spender is updated when a transfer happens
+    event NativeAllowanceUpdated(address indexed spender, uint256 value);
+
+    /// @notice Returns the allowance of a spender
+    function nativeAllowance(address spender) external view returns (uint256);
+
+    /// @notice Returns the transient allowance of a spender
+    function transientNativeAllowance(address spender) external view returns (uint256);
+
+    /// @notice Transfers native tokens from the caller to a recipient
+    /// @dev Doesn't forward transferFrom requests - the specified `from` address must be address(this)
+    function transferFromNative(address from, address recipient, uint256 amount) external returns (bool);
+
+    /// @notice Approves a spender to transfer native tokens on behalf of the caller
+    function approveNative(address spender, uint256 amount) external returns (bool);
+
+    /// @notice Transfers native tokens from the caller to a recipient with transient storage
+    /// @dev Doesn't forward transferFrom requests - the specified `from` address must be address(this)
+    function transferFromNativeTransient(address from, address recipient, uint256 amount) external returns (bool);
+
+    /// @notice Approves a spender to transfer native tokens on behalf of the caller with transient storage
+    function approveNativeTransient(address spender, uint256 amount) external returns (bool);
+}

test/ERC7914Detector.t.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.13;
+
+import {Test} from "forge-std/Test.sol";
+import {ERC7914Detector} from "../src/ERC7914Detector.sol";
+import {IERC7914} from "../src/interfaces/IERC7914.sol";
+import {ICalibur} from "../src/interfaces/ICalibur.sol";
+import {CaliburEntryUtils} from "./util/CaliburEntryUtils.sol";
+import {MockWrongReturnTypeContract} from "./mock/MockWrongReturnTypeContract.sol";
+import {MockNonERC7914Contract} from "./mock/MockNonERC7914Contract.sol";
+
+contract ERC7914DetectorTest is Test {
+    ICalibur public calibur;
+    uint256 signerPrivateKey = 0xa11ce;
+    address signer = vm.addr(signerPrivateKey);
+
+    ERC7914Detector public detector;
+    ICalibur public signerAccount;
+    MockWrongReturnTypeContract public wrongReturnTypeContract;
+    MockNonERC7914Contract public nonERC7914Contract;
+
+    function setUp() public {
+        CaliburEntryUtils caliburEntryUtils = new CaliburEntryUtils();
+        calibur = ICalibur(create2(caliburEntryUtils.getCaliburEntryCode(), bytes32(0)));
+        _delegate(signer, address(calibur));
+        signerAccount = ICalibur(signer);
+
+        detector = new ERC7914Detector(address(calibur));
+        wrongReturnTypeContract = new MockWrongReturnTypeContract();
+        nonERC7914Contract = new MockNonERC7914Contract();
+    }
+
+    function create2(bytes memory initcode, bytes32 salt) internal returns (address contractAddress) {
+        assembly {
+            contractAddress := create2(0, add(initcode, 32), mload(initcode), salt)
+            if iszero(contractAddress) {
+                let ptr := mload(0x40)
+                let errorSize := returndatasize()
+                returndatacopy(ptr, 0, errorSize)
+                revert(ptr, errorSize)
+            }
+        }
+    }
+
+    function _delegate(address _signer, address _implementation) internal {
+        vm.etch(_signer, bytes.concat(hex"ef0100", abi.encodePacked(_implementation)));
+        require(_signer.code.length > 0, "signer not delegated");
+    }
+
+    /// @notice Test ERC7914 detection functionality across different contract types
+    function test_erc7914Detection() public {
+        // Test with non-ERC7914 contract
+        bool hasSupport = detector.hasERC7914Support(address(nonERC7914Contract));
+        assertFalse(hasSupport, "Non-ERC7914 contract should not be detected");
+
+        // Test with EOA
+        address eoa = makeAddr("testEOA");
+        hasSupport = detector.hasERC7914Support(eoa);
+        assertFalse(hasSupport, "EOA should not support ERC7914");
+
+        // Test with ERC7914-supporting contract (calibur address matches signerAccount)
+        hasSupport = detector.hasERC7914Support(address(signerAccount));
+        assertTrue(hasSupport, "ERC7914-supporting contract should be detected");
+
+        // Test with ERC7914-supporting contract (calibur address does not match signerAccount)
+        detector = new ERC7914Detector(address(nonERC7914Contract));
+        hasSupport = detector.hasERC7914Support(address(signerAccount));
+        assertTrue(hasSupport, "ERC7914-supporting contract should be detected");
+    }
+
+    /// @notice Test that contracts with transferFromNative function but wrong return type are not detected as ERC7914
+    function test_erc7914DetectionWrongReturnType() public {
+        // Test with contract that has transferFromNative function but returns uint256 instead of bool
+        bool hasSupport = detector.hasERC7914Support(address(wrongReturnTypeContract));
+        assertFalse(hasSupport, "Contract with wrong return type should not be detected as ERC7914");
+    }
+}

test/FeeOnTransferDetector.t.sol

@@ -112,8 +112,9 @@ contract FeeOnTransferDetectorTest is Test {
     }
 
     function testBasicFotTokenFuzz(uint16 buyFee, uint16 sellFee) public {
-        sellFee = uint16(bound(sellFee, 0, 10000));
-        buyFee = uint16(bound(buyFee, 0, 10000));
+        // detector.validate() will revert if the fee is 0, so we need to bound the fee to 1-9999
+        sellFee = uint16(bound(sellFee, 1, 9999));
+        buyFee = uint16(bound(buyFee, 1, 9999));
         MockFotToken fotToken = new MockFotToken(buyFee, sellFee);
         MockToken otherToken = new MockToken();
         address pair = factory.deployPair(address(fotToken), address(otherToken));
@@ -131,7 +132,8 @@ contract FeeOnTransferDetectorTest is Test {
     }
 
     function testBasicFotTokenWithExternalFeesFuzz(uint16 fee) public {
-        fee = uint16(bound(fee, 0, 10000));
+        // detector.validate() will revert if the fee is 0, so we need to bound the fee to 1-9999
+        fee = uint16(bound(fee, 0, 9999));
         MockFotTokenWithExternalFees fotToken = new MockFotTokenWithExternalFees(fee);
         MockToken otherToken = new MockToken();
         address pair = factory.deployPair(address(fotToken), address(otherToken));

test/mock/BaseAuthorization.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.13;
+
+/// @title BaseAuthorization
+/// @notice A base contract that provides a modifier to restrict access to the contract itself
+contract BaseAuthorization {
+    /// @notice An error that is thrown when an unauthorized address attempts to call a function
+    error Unauthorized();
+
+    /// @notice A modifier that restricts access to the contract itself
+    modifier onlyThis() {
+        if (msg.sender != address(this)) revert Unauthorized();
+        _;
+    }
+}

test/mock/MockNonERC7914Contract.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.13;
+
+import {BaseAuthorization} from "./BaseAuthorization.sol";
+
+/// @title MockNonERC7914Contract
+/// @notice A mock contract that implements BaseAuthorization but NOT ERC7914
+/// @dev Used for testing ERC7914 detection functionality
+contract MockNonERC7914Contract is BaseAuthorization {
+    mapping(address => uint256) public someOtherAllowance;
+
+    constructor() {
+        // No initialization needed for BaseAuthorization
+    }
+
+    /// @notice A function that exists but is not part of ERC7914
+    function setSomeAllowance(address spender, uint256 amount) external onlyThis {
+        someOtherAllowance[spender] = amount;
+    }
+
+    /// @notice Another non-ERC7914 function
+    function transferSomeTokens(address to, uint256 amount) external onlyThis returns (bool) {
+        // Mock implementation - doesn't actually transfer anything
+        emit MockTransfer(address(this), to, amount);
+        return true;
+    }
+
+    /// @notice Receive function to accept ETH
+    receive() external payable {}
+
+    /// @notice Fallback function
+    fallback() external payable {}
+
+    event MockTransfer(address indexed from, address indexed to, uint256 value);
+}

test/mock/MockWrongReturnTypeContract.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.13;
+
+import {BaseAuthorization} from "./BaseAuthorization.sol";
+
+/// @title MockWrongReturnTypeContract
+/// @dev Used for testing ERC7914 detection functionality - has transferFromNative but wrong return type
+contract MockWrongReturnTypeContract is BaseAuthorization {
+    /// @notice This function has the same signature as ERC7914's transferFromNative but returns uint256 instead of bool
+    /// @dev Should cause the detector to return false since it doesn't return a valid boolean
+    function transferFromNative(address, address, uint256) external pure returns (uint256) {
+        // Return a non-boolean value (like 42)
+        return 42;
+    }
+}