problems trying to verify on chain with wagmi signature

[morandalex]

I deployed the following contract

pragma solidity ^0.8.1;

contract VerifySignature {
    
    
    // use this function to get the hash of any string
    function getHash(string memory str) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(str));
    }
    
    
    // take the keccak256 hashed message from the getHash function above and input into this function
    // this function prefixes the hash above with \x19Ethereum signed message:\n32 + hash
    // and produces a new hash signature
    function getEthSignedHash(bytes32 _messageHash) public pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _messageHash));
    }
    
    
    // input the getEthSignedHash results and the signature hash results
    // the output of this function will be the account number that signed the original message
    function verify(bytes32 _ethSignedMessageHash, bytes memory _sig) public pure returns (address) {
        (bytes32 r, bytes32 s, uint8 v) = splitSignature(_sig);
        return ecrecover(_ethSignedMessageHash, v, r, s);
    }

    function splitSignature(bytes memory sig)
        public
        pure
        returns (
            bytes32 r,
            bytes32 s,
            uint8 v
        )
    {
        require(sig.length == 65, "invalid signature length");

        assembly {
            /*
            First 32 bytes stores the length of the signature

            add(sig, 32) = pointer of sig + 32
            effectively, skips first 32 bytes of signature

            mload(p) loads next 32 bytes starting at the memory address p into memory
            */

            // first 32 bytes, after the length prefix
            r := mload(add(sig, 32))
            // second 32 bytes
            s := mload(add(sig, 64))
            // final byte (first byte of the next 32 bytes)
            v := byte(0, mload(add(sig, 96)))
        }

        // implicitly return (r, s, v)
    }

}    

So , I use the method getHash in order to retrieve the hash for the word "ciao".
And then I retrieve the eth signed from getEthSignedHash function.
I connect with Metamask with wagmi and with the hook useSignMessage I can get the signature.

const [{ data, error, loading }, signMessage] = useSignMessage()

<Button
type='submit'
mt={4}
onClick={() => { signMessage({ message }) }}
disabled={loading || !message.length}
>
{loading ? 'Check Wallet' : 'Sign Message'}
</Button>

But, when I put the signature string inside the contract method verify , I cannot get back the address connected with wagmi, but another unknown.
It seems that I am not signing with my address but with another.

But if I use the console ( so not wagmi lbrary ) , I can get a different signature tha if I use it inside verify function then I get my address.
The script in the remix console is the following:

hash="<copy the hash of the message>"
ethereum.enable().then(console.log)
account="<put here the address that you are using and it is connected to metamask>"
ethereum.request({method: "personal_sign", params: [account, hash]}).then(console.log)
//then copy the signature and use it in _verify_ contract method , then you should get the address that signed the message