Custodial Wallet smart contract code with support for ERC20 tokens

CustodialWallet.sol

pragma solidity ^0.8.0;

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

contract CustodialWallet {
    mapping(address => uint) etherBalances;
    mapping(address => mapping(address => uint)) tokenBalances;
    mapping(address => mapping(address => uint)) allowed;

    address owner;

    constructor() {
        owner = msg.sender;
    }

    function depositEther() public payable {
        etherBalances[owner] += msg.value;
    }

    function withdrawEther(address payable to, uint amount) public {
        require(msg.sender == owner, "Not authorized");
        require(address(this).balance >= amount, "Insufficient balance");
        to.transfer(amount);
    }

    function transferEther(address payable to, uint amount) public {
        require(msg.sender == owner, "Not authorized");
        require(address(this).balance >= amount, "Insufficient balance");
        to.transfer(amount);
    }

    function depositToken(IERC20 token, uint amount) public {
        require(token.transferFrom(msg.sender, address(this), amount), "Failed to transfer tokens");
        tokenBalances[owner][address(token)] += amount;
    }

    function withdrawToken(IERC20 token, address to, uint amount) public {
        require(msg.sender == owner, "Not authorized");
        require(tokenBalances[owner][address(token)] >= amount, "Insufficient balance");
        require(token.transfer(to, amount), "Failed to transfer tokens");
        tokenBalances[owner][address(token)] -= amount;
    }

    function transferToken(IERC20 token, address to, uint amount) public {
        require(msg.sender == owner, "Not authorized");
        require(tokenBalances[owner][address(token)] >= amount, "Insufficient balance");
        require(token.transfer(to, amount), "Failed to transfer tokens");
        tokenBalances[owner][address(token)] -= amount;
    }

    function approveToken(IERC20 token, address spender, uint amount) public {
        allowed[owner][spender] = amount;
        require(token.approve(spender, amount), "Failed to approve token");
    }

    function transferTokenFrom(IERC20 token, address from, address to, uint amount) public {
        require(allowed[from][msg.sender] >= amount, "Not authorized");
        require(tokenBalances[from][address(token)] >= amount, "Insufficient balance");
        require(token.transferFrom(from, to, amount), "Failed to transfer tokens");
        allowed[from][msg.sender] -= amount;
        tokenBalances[from][address(token)] -= amount;
        tokenBalances[to][address(token)] += amount;
    }

    function etherBalanceOf() public view returns (uint) {
        return etherBalances[owner];
    }

    function tokenBalanceOf(IERC20 token) publicview returns (uint) {
        return tokenBalances[owner][address(token)];
    }

    function allowanceOf(IERC20 token, address spender) public view returns (uint) {
        return allowed[owner][spender];
    }
}