How to convert an bytes to address in Solidity?

Question

How to convert bytes or string (eg: 0xf2bd5de8b57ebfc45dcee97524a7a08fccc80aef) to address in solidity?

Answer 1

I feel like there might be a more efficient way to do this but here's my naive solution:

function bytesToAddress (bytes b) constant returns (address) {
    uint result = 0;
    for (uint i = 0; i < b.length; i++) {
        uint c = uint(b[i]);
        if (c >= 48 && c <= 57) {
            result = result * 16 + (c - 48);
        }
        if(c >= 65 && c<= 90) {
            result = result * 16 + (c - 55);
        }
        if(c >= 97 && c<= 122) {
            result = result * 16 + (c - 87);
        }
    }
    return address(result);
}

Answer 2

If the bytes argument is of length 20, that is, the length of an address, this assembly one-liner works for me:

function bytesToAddress(bytes bys) private pure returns (address addr) { assembly { addr := mload(add(bys,20)) } }

Answer 3

Other solution:

function bytesToAddress(bytes calldata b) private pure returns (address) {
    return address(uint160(bytes20(b)));
}  

Answer 4

If the bytes argument has a standard length of 64, that is, the first 32 bytes specify its length and the second 32 bytes specify its content, do this:

function bytesToAddress(bytes bys) private pure returns (address addr) {
    assembly {
        addr := mload(add(bys, 32))
    } 
}

All credit goes to Paul Steckler

Answer 5

if address was packed using abi.encodedPacked(address) then this would work, since you need to pad left to get the correct bytes back

assembly {
    parsed := div(mload(add(data, 32)), 0x1000000000000000000000000)
}

or (div by 0x1.... is like doing >> 96)

assembly {
    parsed := shr(96, mload(add(data, 32)))
}

Answer 6

Converting from bytes (or string) to address:

  function bytesToAddress(bytes _address) public returns (address) {
    uint160 m = 0;
    uint160 b = 0;

    for (uint8 i = 0; i < 20; i++) {
      m *= 256;
      b = uint160(_address[i]);
      m += (b);
    }

    return address(m);
  }

Usage

address addr = bytesToAddress("0xa462d983B4b8C855e1876e8c24889CBa466A67EB");

If calling from Remix IDE, pass bytes like this:

["0xa4", "0x62", "0xd9", "0x83", "0xB4", "0xb8", "0xC8", "0x55", "0xe1", "0x87", "0x6e", "0x8c", "0x24", "0x88", "0x9C", "0xBa", "0x46", "0x6A", "0x67", "0xEB"]

Answer 7

erkt's answer didn't work for me this is the solution I wrote based on it. It converts the hex bytes to uint and sums them all up then converts the uint sum to an address:

function bytesToAddr (bytes b) constant returns (address) {
  uint result = 0;
  for (uint i = b.length-1; i+1 > 0; i--) {
    uint c = uint(b[i]);
    uint to_inc = c * ( 16 ** ((b.length - i-1) * 2));
    result += to_inc;
  }
  return address(result);
}

Answer 8

STRING to ADDRESS:

You can use Oraclize's own helper method:

contract usingOraclize { function parseAddr(string _a) internal returns (address); ... }

There https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_pre0.4.sol#L149

    function parseAddr(string _a) internal returns (address){
     bytes memory tmp = bytes(_a);
     uint160 iaddr = 0;
     uint160 b1;
     uint160 b2;
     for (uint i=2; i<2+2*20; i+=2){
         iaddr *= 256;
         b1 = uint160(tmp[i]);
         b2 = uint160(tmp[i+1]);
         if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
         else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
         if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
         else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
         iaddr += (b1*16+b2);
     }
     return address(iaddr);
    }

Answer 9

Here is how I would do this:

// Convert 32 hexadecimal digits into 16 bytes.
function hexToBytes16 (bytes32 h) internal pure returns (bytes16 b) {
    unchecked {
        // Ensure all chars below 128
        require (h & 0x8080808080808080808080808080808080808080808080808080808080808080 == 0);

        // Subtract '0' from every char
        h = bytes32 (uint256 (h) - 0x3030303030303030303030303030303030303030303030303030303030303030);

        // Ensure all chars still below 128, i.e. no underflow in the previous line
        require (h & 0x8080808080808080808080808080808080808080808080808080808080808080 == 0);

        // Calculate mask for chars that originally were above '9'
        bytes32 ndm = bytes32 ((((uint256(h) + 0x7676767676767676767676767676767676767676767676767676767676767676) & 0x8080808080808080808080808080808080808080808080808080808080808080) >> 7) * 0xFF);

        // Subtract 7 ('A' - '0') from every char that originally was above '9'
        h = bytes32 (uint256 (h) - uint256 (ndm & 0x0707070707070707070707070707070707070707070707070707070707070707));

        // Ensure all chars still below 128, i.e. no underflow in the previous line
        require (h & 0x8080808080808080808080808080808080808080808080808080808080808080 == 0);

        // Ensure chars that originally were above '9' are now above 9
        require (uint256 (h) - uint256 (ndm & 0x0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A) & 0x8080808080808080808080808080808080808080808080808080808080808080 == 0);

        // Calculate Mask for chars that originally were above 'F'
        bytes32 lcm = bytes32 ((((uint256(h) + 0x7070707070707070707070707070707070707070707070707070707070707070) & 0x8080808080808080808080808080808080808080808080808080808080808080) >> 7) * 0xFF);

        // Subtract 32 ('a' - 'A') from all chars that oroginally were above 'F'
        h = bytes32 (uint256 (h) - uint256 (lcm & 0x2020202020202020202020202020202020202020202020202020202020202020));

        // Ensure chars that originally were above 'F' are now above 9
        require (uint256 (h) - uint256 (lcm & 0x0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A) & 0x8080808080808080808080808080808080808080808080808080808080808080 == 0);

        // Ensure all chars are below 16
        require (h & 0xF0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0 == 0);

        // 0x0A0B0C0D... -> 0xAB00CD00...
        h = (h & 0x0F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F00) << 4 | (h & 0x000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F) << 8;

        // 0xAA00BB00CC00DD00... -> 0xAABB0000CCDD0000...
        h = h & 0xFF000000FF000000FF000000FF000000FF000000FF000000FF000000FF000000 | (h & 0x0000FF000000FF000000FF000000FF000000FF000000FF000000FF000000FF00) << 8;

        // 0xAAAA0000BBBB0000CCCC0000DDDD0000... -> 0xAAAABBBB00000000CCCCDDDD00000000...
        h = h & 0xFFFF000000000000FFFF000000000000FFFF000000000000FFFF000000000000 | (h & 0x00000000FFFF000000000000FFFF000000000000FFFF000000000000FFFF0000) << 16;

        // 0xAAAAAAAA00000000BBBBBBBB00000000CCCCCCCC00000000DDDDDDDD00000000 -> 0xAAAAAAAABBBBBBBB0000000000000000CCCCCCCCDDDDDDDD0000000000000000
        h = h & 0xFFFFFFFF000000000000000000000000FFFFFFFF000000000000000000000000 | (h & 0x0000000000000000FFFFFFFF000000000000000000000000FFFFFFFF00000000) << 32;

        // 0xAAAAAAAAAAAAAAAA0000000000000000BBBBBBBBBBBBBBBB0000000000000000 -> 0xAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB00000000000000000000000000000000
        h = h & 0xFFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000 | (h & 0x00000000000000000000000000000000FFFFFFFFFFFFFFFF0000000000000000) << 64;

        // Trim to 16 bytes
        b = bytes16 (h);
    }
}

function parseAddress (string memory s) public pure returns (address) {
    require (bytes(s).length == 42);
    bytes2 prefix;
    bytes32 leftHex;
    bytes32 rightHex;
    assembly {
        prefix := mload (add (s, 0x20))
        leftHex := mload (add (s, 0x22))
        rightHex := mload (add (s, 0x2A))
    }
    require (prefix == '0x');
    bytes16 left = hexToBytes16(leftHex);
    bytes16 right = hexToBytes16(rightHex);
    return address (bytes20 (left) | bytes20 (right) >> 32);
}

This approach is significantly more efficient, than the accepted answer. Also it reverts on invalid addresses.

Answer 10

Not sure if this is what you mean:

Use mapping. Try something like this:

mapping (string => address) variable;

then assign: variable["hello"] = address;

variable["hello"]; // should return an address