TokenDetectionLib

{{
  "language": "Solidity",
  "sources": {
    "contracts/libraries/TokenDetectionLib.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

/**
 * @title TokenDetectionLib
 * @dev Library for detecting token capabilities and standards
 */
library TokenDetectionLib {
    
    /**
     * @dev Check if a token supports transferWithAuthorization
     */
    function supportsTransferWithAuthorization(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature(
                "transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)",
                address(0), address(0), 0, 0, 0, bytes32(0), 0, bytes32(0), bytes32(0)
            )
        );
        return success;
    }

    /**
     * @dev Check if a token supports standard ERC-2612 permit
     */
    function supportsStandardPermit(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature(
                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)",
                address(0), address(0), 0, 0, 0, bytes32(0), bytes32(0)
            )
        );
        return success;
    }

    /**
     * @dev Check if a token supports DAI-style custom permit
     */
    function supportsDaiPermit(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature(
                "permit(address,address,uint256,uint256,bool,uint8,bytes32,bytes32)",
                address(0), address(0), 0, 0, false, 0, bytes32(0), bytes32(0)
            )
        );
        return success;
    }

    /**
     * @dev Check if a token supports ERC-1271 signature validation
     */
    function supportsERC1271(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature("isValidSignature(bytes32,bytes)", bytes32(0), "")
        );
        return success;
    }

    /**
     * @dev Check if a token supports ERC-777
     */
    function supportsERC777(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature("authorizeOperator(address)", address(0))
        );
        return success;
    }

    /**
     * @dev Check if a token supports ERC-1155
     */
    function supportsERC1155(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature(
                "safeTransferFrom(address,address,uint256,uint256,bytes)",
                address(0), address(0), 0, 0, ""
            )
        );
        return success;
    }

    /**
     * @dev Check if a token has fee-on-transfer mechanism
     */
    function supportsFeeOnTransfer(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success1, ) = token.staticcall(abi.encodeWithSignature("fee()"));
        (bool success2, ) = token.staticcall(abi.encodeWithSignature("transferFee()"));
        (bool success3, ) = token.staticcall(abi.encodeWithSignature("burnRate()"));
        
        return success1 || success2 || success3;
    }

    /**
     * @dev Check if a token supports meta transactions
     */
    function supportsMetaTransaction(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success1, ) = token.staticcall(abi.encodeWithSignature("executeMetaTransaction(address,bytes)", address(0), ""));
        (bool success2, ) = token.staticcall(abi.encodeWithSignature("executeTransaction(address,uint256,bytes)", address(0), 0, ""));
        (bool success3, ) = token.staticcall(abi.encodeWithSignature("executeCall(address,uint256,bytes)", address(0), 0, ""));
        
        return success1 || success2 || success3;
    }

    /**
     * @dev Check if an address supports EIP-7702 (EOA with temporary smart contract functionality)
     */
    function supportsEIP7702(address eoa) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(eoa) }
        return size == 0; // Only EOAs can support EIP-7702
    }

    /**
     * @dev Detect the type of permit a token uses
     * @return permitType 0=none, 1=standard ERC-2612, 2=DAI custom, 3=other custom
     */
    function detectPermitType(address token) external view returns (uint8 permitType) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return 0;
        
        // Check for standard ERC-2612 permit
        (bool standardSuccess, ) = token.staticcall(
            abi.encodeWithSignature(
                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)",
                address(0), address(0), 0, 0, 0, bytes32(0), bytes32(0)
            )
        );
        
        if (standardSuccess) return 1;
        
        // Check for DAI-style permit
        (bool daiSuccess, ) = token.staticcall(
            abi.encodeWithSignature(
                "permit(address,address,uint256,uint256,bool,uint8,bytes32,bytes32)",
                address(0), address(0), 0, 0, false, 0, bytes32(0), bytes32(0)
            )
        );
        
        if (daiSuccess) return 2;
        
        return 0;
    }


    /**
     * @dev Check if a token supports approve function
     */
    function supportsApprove(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature("approve(address,uint256)", address(0), 0)
        );
        return success;
    }

    /**
     * @dev Check if a token supports increaseAllowance function
     */
    function supportsIncreaseAllowance(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature("increaseAllowance(address,uint256)", address(0), 0)
        );
        return success;
    }

    /**
     * @dev Check if a token supports allowance function
     */
    function supportsAllowance(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature("allowance(address,address)", address(0), address(0))
        );
        return success;
    }

    /**
     * @dev Check if a token supports balanceOf function
     */
    function supportsBalanceOf(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature("balanceOf(address)", address(0))
        );
        return success;
    }

    /**
     * @dev Check if a token supports transfer function
     */
    function supportsTransfer(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature("transfer(address,uint256)", address(0), 0)
        );
        return success;
    }

    /**
     * @dev Check if a token supports transferFrom function
     */
    function supportsTransferFrom(address token) external view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(token) }
        if (size == 0) return false;
        
        (bool success, ) = token.staticcall(
            abi.encodeWithSignature("transferFrom(address,address,uint256)", address(0), address(0), 0)
        );
        return success;
    }

}
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "viaIR": true,
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    }
  }
}}