EIP-712: Array support

[bitpshr]

The original implementation of signTypedData omitted array support. This pull request remedies this by adding array support as per EIP-712 along with updated tests.

[rmeissner]

I would recommend adding an independent test for this, to avoid changing the test values provided in the EIP, this way it is also ensured that the previous behaviour did not break.

[bitpshr]

Hi @rmeissner, thanks for the feedback. I submitted an upstream PR to update the EIP test values (see ethereum/EIPs#1242.) While we don't plan to land this PR until that upstream PR also lands, you're right that separate tests would be more robust. Will update.

[rmeissner]

when creating the typeHash a lookup is performed based on the type. In this case the type would be Person[], so it would not match Person in the types dictionary.

In the test this works since from references Person, but would be interesting if it still works when we remove that reference.

[rmeissner]

When implementing this in python it seems like that these test values are wrong.

To verify this I created a smart contract on remix:

pragma solidity 0.4.24;

contract Test {
    
    function personData()
        public
        pure
        returns (bytes) 
    {
        bytes32 personSchemaHash = keccak256("Person(string name,address wallet)");
        return abi.encode(
            personSchemaHash,
            keccak256('Bob'),
            address(0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB)
        );
    }
    
    function signData()
        public
        pure
        returns (bytes) 
    {
        bytes32 personSchemaHash = keccak256("Person(string name,address wallet)");
        return abi.encode(
            0xdd57d9596af52b430ced3d5b52d4e3d5dccfdf3e0572db1dcf526baad311fbd1,
            keccak256(
                abi.encode(
                    personSchemaHash,
                    keccak256('Cow'),
                    address(0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826)
                )
            ),
            keccak256(personData()),
            keccak256("Hello, Bob!")
        );
    }
    
    function signHash()
        public
        pure
        returns (bytes32) 
    {
        return keccak256(signData());
    }
    
    function sign()
        public
        pure
        returns (bytes32) 
    {
        return keccak256(abi.encodePacked(
            byte(0x19), 
            byte(1), 
            0xf2cee375fa42b42143804025fc449deafd50cc031ca257e0b194a650a912090f, 
            signHash()
        ));
    }
}

The issue seems to be in the code where the array data is concatenated (see comment above)

[rmeissner]

I seems that join converts this into a string and result in a wrong hash (see comment in tests)

To fix this use:
Buffer.concat(value.map(item => this.encodeData(parsedType, item, types)))

[danfinlay]

I'd like to see the comments posted by rmeissner addressed before merging.

[bitpshr]

Closing this for now and will re-open when EIP-712 array support firms up. Per the proposal's author:

In the screencast I see that arrays are implemented. This is still somewhat subject to change in EIP712. What I think will happen is that EIP712 will follow whatever encoding Solidity uses internally in memory and/or what ABIv2 uses. This may or may not be the same as what is currently specified. If there is a change, I expect it will be in the handling of fixed size arrays.