Hashing algorithms

StructuredHashes.sol

pragma solidity 0.4.20;

contract StructuredHashes {
    
    struct Order {
        address maker;
        address taker;
        address makerToken;
        address takerToken;
        address feeRecipient;
        uint256 makerTokenAmount;
        uint256 takerTokenAmount;
        uint256 makerFee;
        uint256 takerFee;
        uint256 expirationTimestampInSec;
        bytes32 orderHash;
    } // size 11 * 32 = 352
    
    struct MakerMessage {
        address exchange;
        Order order;
    } // Size 2 * 32 = 64
    
    function test() public view returns(bool) {
        Order memory order = Order(this, this, this, this, this, 2, 1, 2, 3, 4, 5);
        MakerMessage memory mm = MakerMessage(this, order);
        // 1396
        return hash1(mm) == hash2(mm); // Returns true
    }
    
    function hash0(MakerMessage memory mm) private pure returns(bytes32 hash) {
        // 757 gas
        return keccak256(
            mm.exchange,
            keccak256(
                mm.order.maker,
                mm.order.taker,
                mm.order.makerToken,
                mm.order.takerToken,
                mm.order.feeRecipient,
                mm.order.makerTokenAmount,
                mm.order.takerTokenAmount,
                mm.order.makerFee,
                mm.order.takerFee,
                mm.order.expirationTimestampInSec,
                mm.order.orderHash
            )
        );
    }

    function hash1(MakerMessage memory mm) private pure returns(bytes32 hash) {
        // 968 gas
        return keccak256(
            bytes32(mm.exchange),
            keccak256(
                bytes32(mm.order.maker),
                bytes32(mm.order.taker),
                bytes32(mm.order.makerToken),
                bytes32(mm.order.takerToken),
                bytes32(mm.order.feeRecipient),
                bytes32(mm.order.makerTokenAmount),
                bytes32(mm.order.takerTokenAmount),
                bytes32(mm.order.makerFee),
                bytes32(mm.order.takerFee),
                bytes32(mm.order.expirationTimestampInSec),
                bytes32(mm.order.orderHash)
            )
        );
    }
    
    function hash2(MakerMessage memory mm) private pure returns(bytes32 hash) {
        // 416 gas
        Order memory order = mm.order;
        assembly {
            let orderhash := keccak256(order, 352)
            let tmp := mload(add(mm, 32))
            mstore(add(mm, 32), orderhash)
            hash := keccak256(mm, 64)
            mstore(add(mm, 32), tmp)
        }
    }
}