Update EIP-152: Fix reference test

EIPS/eip-152.md

@@ -9,7 +9,7 @@
 created: 2016-10-04
 ---
 
 ## Simple Summary
 
 This EIP will enable the BLAKE2b hash function and other higher-round 64-bit BLAKE2 variants to run cheaply on the EVM, allowing easier interoperability between Ethereum and Zcash as well as other Equihash-based PoW coins.
 
@@ -27,9 +27,9 @@
 
 ## Specification
 
 We propose adding a precompiled contract at address `0x09` wrapping the [BLAKE2 `F` compression function](https://tools.ietf.org/html/rfc7693#section-3.2).
 
 The precompile requires 6 inputs tightly encoded, taking exactly 213 bytes, as explained below. The encoded inputs are corresponding to the ones specified in the [BLAKE2 RFC Section 3.2](https://tools.ietf.org/html/rfc7693#section-3.2):
 
 - `rounds` - the number of rounds - 32-bit unsigned big-endian word
 - `h` - the state vector - 8 unsigned 64-bit little-endian words
@@ -45,7 +45,7 @@
 The boolean `f` parameter is considered as `false` if set to `0`.
 All other values yield an invalid encoding of `f` error.
 
 The precompile should compute the `F` function as [specified in the RFC](https://tools.ietf.org/html/rfc7693#section-3.2) and return the updated state vector `h` with unchanged encoding (little-endian).
 
 ### Example Usage in Solidity
 
@@ -80,8 +80,8 @@
   m[3] = hex"0000000000000000000000000000000000000000000000000000000000000000";
 
   bytes8[2] memory t;
-  t[0] = hex"03000000";
-  t[1] = hex"00000000";
+  t[0] = hex"0300000000000000";
+  t[1] = hex"0000000000000000";
 
   bool f = true;
 
@@ -104,16 +104,16 @@
 
 An obvious implementation would be a direct BLAKE2b hash function precompile. At first glance, a BLAKE2b precompile satisfies most hashing and interoperability requirements on the EVM. Once we started digging in, however, it became clear that any BLAKE2b implementation would need specific features and internal modifications based on different projects' requirements and libraries.
 
 A [thread with the Zcash team](https://github.com/ethereum/EIPs/issues/152#issuecomment-499240310) makes the issue clear.
 
 > The minimal thing that is necessary for a working ZEC-ETH relay is an implementation of BLAKE2b Compression F in a precompile.
 
 > A BLAKE2b Compression Function F precompile would also suffice for the Filecoin and Handshake interop goals.
 
 > A full BLAKE2b precompile would suffice for a ZEC-ETH relay, provided that the implementation provided the parts of the BLAKE2 API that we need (personalization, maybe something else—I'm not sure).
 
 > I'm not 100% certain if a full BLAKE2b precompile would also suffice for the Filecoin and Handshake goals. It almost certainly could, provided that it supports all the API that they need.
 
 > BLAKE2s — whether the Compression Function F or the full hash — is only a nice-to-have for the purposes of a ZEC-ETH relay.
 
 From this and other conversations with teams in the space, we believe we should focus first on the `F` precompile as a strictly necessary piece for interoperability projects. A BLAKE2b precompile is a nice-to-have, and we support any efforts to add one-- but it's unclear whether complete requirements and a flexible API can be found in time for Istanbul.
@@ -126,11 +126,11 @@
 
 ## Test Cases
 
 #### Test vector 0
 * input: (empty)
 * output: error "input length for BLAKE2 F precompile should be exactly 213 bytes"
 
 #### Test vector 1
 * input:
 `00000c48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000001`
 * output: error "input length for BLAKE2 F precompile should be exactly 213 bytes"
@@ -176,15 +176,15 @@
 
 ## Implementation
 
 An initial implementation of the `F` function in Go, adapted from the standard library, can be found in our [Golang BLAKE2 library fork](https://github.com/keep-network/blake2-f). There's also an implementation of the precompile in our fork of [go-ethereum](https://github.com/keep-network/go-ethereum/pull/4).
 
 ## References
 
 For reference, further discussion on this EIP also occurred in the following PRs and issues
 
  * [Original Issue](https://github.com/ethereum/EIPs/issues/152)
  * [Ethereum Magicians](https://ethereum-magicians.org/t/blake2b-f-precompile/3157)
  * [PR 2129](https://github.com/ethereum/EIPs/pull/2129)
 
 ## Appendix - benchmarks