Hashing that matches Solidity `keccak256(abi.encode(...))`

I spent a long time figuring out why I could not get matching hashes between Solidity and Ethers using the solidityKeccak256 function with dynamic types (i.e. string).

Example Solidity contract:

pragma solidity ^0.5.0;

contract TestingHashes {
    function hash() public pure returns (bytes32) {
        return keccak256(abi.encode("Hello", "world!"));
    }
    
    function hashPacked() public pure returns (bytes32) {
        return keccak256(abi.encodePacked("Hello", "world!"));
    }
}

In Ethers, if I use the hash function:

eth.utils.solidityKeccak256(["string", "string"], ["Hello", "world!"]);

The above matches the output of the Solidity function hashPacked. However, as the Solidity docs state, the packed encoding is ambiguous. Is there a way to mimic the behavior of abi.encode in Ethers?

[ricmoo]

Right, the packed encoding is ambiguous. For example, imagine the following two cases:

// A
const a = solidityPack([ "bytes1", "bytes2" ], [ "0x12", "0x3456" ]);

//
const b = solidityPack([ "bytes2", "bytes1" ], [ "0x1234", "0x56" ]);

Both will have the same packed representation and hence the same hash. This can allow a malicious actor to trick your contract. So in general you need to use a distinguished encoding. The abi.encode in Solidity is mirrored in ethers, so they should both produce the same, non-ambiguous data; however abi encoding is not truly distinguished, as there are multiple ways to encode the same data, it’s just the most popular implementations all behave the same, so this point is moot (ish).

To get the result that matches hash(), you can use:

/home/ethers> ethers
homestead> ethers.utils.defaultAbiCoder.encode([ "string", "string" ], [ "Hello", "world" ])
'0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000548656c6c6f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005776f726c64000000000000000000000000000000000000000000000000000000'
homestead> ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode([ "string", "string" ], [ "Hello", "world" ]))
'0x5ac989f52ea4c399343f6c0cf5a4810fc1bdac5773de37ca0cd0a8287f75a5c6'

I am also working on an EIP for a scheme that provides an actual distinguished encoding too, but I’ve been quite busy and haven’t had a chance to follow up on some feedback for it. I’ll bump it up my todo list. 😃

Make sense? Feel free to ask follow-up questions. 😃

[mikoim]

I found different behavior. If struct have no array, ethers.utils.defaultAbiCoder.encode works expected. Otherwise, defaultAbiCoder adds array length before elements so bytes does not match abi.encode’s one .

test.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;

contract Test {
    struct Boo {
        uint256[] ids;
    }

    function foo(Boo memory data) external view returns (bytes memory) {
        return abi.encode(data);
    }
}

Test.test.ts

import { expect } from "chai";
import { ethers } from "hardhat";

describe("Test: ", function () {
  let Test: any;
  let test: any;

  before(async function () {
    Test = await ethers.getContractFactory("Test");
  });

  beforeEach(async function () {
    test = await Test.deploy();
  });

  it("Array in struct", async function () {
    {
      const data = ethers.utils.defaultAbiCoder.encode(["uint256[]"], [[0, 1, 2, 3, 4, 5]]);

      expect(await test.test([[0, 1, 2, 3, 4, 5]])).to.equal(data);
    }
  });
});

  1) Test: 
       Array in struct:

      AssertionError: expected '0x00000000000000000000000000000000000…' to equal '0x00000000000000000000000000000000000…'
      + expected - actual

      -0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000005
      +0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000005
      
      at Context.<anonymous> (test/Test.test.ts:20:56)

---

tuple works 😉

ethers.utils.defaultAbiCoder.encode(["tuple(uint256[])"], [[[0, 1, 2, 3, 4, 5]]]);