How do I get an address with a correct checksum, from an address with an incorrect checksum, using Solidity?

Question

Example of an address with the wrong checksum:

0xa54D3c09E34aC96807c1CC397404bF2B98DC4eFb

Example of an address with the right checksum:

0xa54d3c09E34aC96807c1CC397404bF2B98DC4eFb

-Difference is the first letter "D".

Which function call should I make in Solidity to convert the wrong checksum address to a right checksum address ?

Answer 1

The simple answer is that in solidity:

address(0xa54D3c09E34aC96807c1CC397404bF2B98DC4eFb);

It is true that the compiler warns you of incorrect checksum when it sees one, but that warning is probably there just to tell you that you might have gotten the wrong address altogether (because typically, constant addresses are copy-pasted from one place to another, and copy-pasting would not "accidentally" change some upper-case letter to lower-case or vice versa).

The Solidity compiler tells you exactly how you can fix it (manually):

SyntaxError: This looks like an address but has an invalid checksum. Correct checksummed address: "0xa54d3c09E34aC96807c1CC397404bF2B98DC4eFb". If this is not used as an address, please prepend '00'. For more information please see solidity.readthedocs.io/en/develop/types.html#address-literals address(0xa54D3c09E34aC96807c1CC397404bF2B98DC4eFb);

The solution then becomes:

Hexadecimal literals that pass the address checksum test, for example 0xdCad3a6d3569DF655070DEd06cb7A1b2Ccd1D3AF are of address payable type. Hexadecimal literals that are between 39 and 41 digits long and do not pass the checksum test produce an error. You can prepend (for integer types) or append (for bytesNN types) zeros to remove the error.

But again, these two constants are identical, and they will yield the exact same runtime-behavior.

Answer 2

As mentioned in comments Solidity doesn't have such functionality. Solidity (and also EVM) doesn't understand anything about address checksums, it's only a construct added on top of the toolkits.

If you really really want to you can calculate it yourself in Solidity. Here's the original EIP: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-55.md with some example code. But I fail to see why you'd want to do that.

Answer 3

We can get help from the solidity compiler since it's showing the fixed checksummed address in below compiler error

SyntaxError: This looks like an address but has an invalid checksum. Correct checksummed address: "0xa54d3c09E34aC96807c1CC397404bF2B98DC4eFb". If this is not used as an address, etc..

Answer 4

Other colleagues did underline very well the point: in Solidity does not exist something called “address with correct checksum”. There exist addresses. Full stop.

The request for a proper checksum comes from the user interface of the IDE, like remix or similar, just to ask you to double check your address. But just for this.

You can obtain your correct checksum address treating it as a string, then applying the EIP 55 rules, then converting it back to address.

But this do not make sense in a smart contract: never. And it does not make sense to record that on blockchain. It is something like using EVM and paying ethers at running time to indent properly the source code. It, if required, is to be done offline, by means of some JavaScript or C.

In other word: the CRC is a “cosmetic” element useful for the interface to the IDE, like comments in green and between /* and */.

You are asking something like “I want to format comments in solidity”.

This does not make sense. At run time do not exist anymore both indenting and comments and CRC for addresses.

I hope this can help.

Answer 5

The solution is simple...

https://solidity.readthedocs.io/en/develop/types.html#address-literals

Hexadecimal literals that pass the address checksum test, for example 0xdCad3a6d3569DF655070DEd06cb7A1b2Ccd1D3AF are of address payable type. Hexadecimal literals that are between 39 and 41 digits long and do not pass the checksum test produce an error. You can prepend (for integer types) or append (for bytesNN types) zeros to remove the error.

Furthermore, I can use the address however I want and convert it to a String with the proper checksum if I need it.

Answer 6

I found a solution just copy the address to Etherscan.io and paste it to see the tokens and transactions in the wallet, then check at the top the address that etherscan shows its the address with the right checksum. this worked for me

Answer 7

I had a use-case where hash of the checksummed address (as string) was already committed, and I needed to check if the address provided later matched it on chain. Thus, I needed to compute the checksummed hex string of the address. Here is my implementation of EIP-55 in solidity:

bytes16 private constant HEX_DIGITS = "0123456789abcdef";
bytes16 private constant HEX_CAPITAL = "0123456789ABCDEF";

function toChecksumHexString(address addr) public pure returns (string memory) {
    bytes memory lowercase = new bytes(40);
    uint160 currentAddressValue = uint160(addr);
    for (uint i = 40; i > 0; --i) {
        lowercase[i-1] = HEX_DIGITS[currentAddressValue & 0xf];
        currentAddressValue >>= 4;
    }
    bytes32 hashed_addr = keccak256(abi.encodePacked(lowercase));

    bytes memory buffer = new bytes(42);
    buffer[0] = '0';
    buffer[1] = 'x';

    uint160 addrValue = uint160(addr);
    uint160 hashValue = uint160(bytes20(hashed_addr));
    for (uint i = 41; i>1; --i) {
        uint hashIndex = hashValue & 0xf;
        if (hashIndex > 7) {
            buffer[i] = HEX_CAPITAL[addrValue & 0xf];
        }
        else {
            buffer[i] = HEX_DIGITS[addrValue & 0xf];
        }
        addrValue >>= 4;
        hashValue >>= 4;
    }
    return string(abi.encodePacked(buffer));
}

I have raised an issue on openzeppelin to add it to their string utils, hopefully an implementation will be added soon.