0xec0d...b4c8

Utility

0xec0d003dbc24...c469fe5cb4c8

Tangerine WhistleExact Bytecode MatchEdit this contract

Deployed November 2, 2016 (9 years ago)Block 2,555,172

Signature recovery library for the Devcon 2 attendee token

Tangerine Whistle EraVerified Source

Historical Significance

An early piece of shared signature checking code, written when ecrecover still returned zero on failure and callers had to guard against it themselves.

Context

Deployed in the Homestead era, two months after Devcon 2 in Shanghai.

Key Facts

Deployer

Piper Merriam(0xd3cda9...293601)

Deployment Block

2,555,172

Deployment Date

Nov 2, 2016, 09:46 PM

Code Size

523.0 B

Deployment Transaction: 0x579221f77cb4a88b...126940192c60327a

Description

ECVerifyLib wraps the ecrecover precompile so that a failed call is reported rather than silently returning a zero address, and adds a helper that splits a 65 byte signature into its v, r and s parts. The Devcon 2 token used it to check that a claim was signed by the key printed on an attendee badge. Deployed on 2 November 2016 by 0xd3cda913deb6f67967b99d67acdfa1712c293601, the account of Piper Merriam, and recovered from pipermerriam/devcon2-token.

Source Verified

Exact bytecode match(523 bytes)

Compiler: v0.4.2+

View verification proof

Heuristic Analysis

The following characteristics were detected through bytecode analysis and may not be accurate.

Detected Type: Utility

Tangerine Whistle Era

Emergency fork to address DoS attacks. Repriced IO-heavy opcodes.

Block span: 2,463,000 — 2,674,999

October 18, 2016 — November 22, 2016

Bytecode Overview

Opcodes523

Unique Opcodes74

Jump Instructions25

Storage Operations6

Verified Source Available

Source verified through compiler archaeology and exact bytecode matching.

Verified on Etherscan (similar match)

View Verification Proof

Show source code (Solidity)

// Submitted by EthereumHistory (ethereumhistory.com)
pragma solidity ^0.4.0;


library ECVerifyLib {
    // From: https://gist.github.com/axic/5b33912c6f61ae6fd96d6c4a47afde6d
    // Duplicate Solidity's ecrecover, but catching the CALL return value
    function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
        // We do our own memory management here. Solidity uses memory offset
        // 0x40 to store the current end of memory. We write past it (as
        // writes are memory extensions), but don't update the offset so
        // Solidity will reuse it. The memory used here is only needed for
        // this context.

        // FIXME: inline assembly can't access return values
        bool ret;
        address addr;

        assembly {
            let size := mload(0x40)
            mstore(size, hash)
            mstore(add(size, 32), v)
            mstore(add(size, 64), r)
            mstore(add(size, 96), s)

            // NOTE: we can reuse the request memory because we deal with
            //       the return code
            ret := call(3000, 1, 0, size, 128, size, 32)
            addr := mload(size)
        }

        return (ret, addr);
    }

    function ecrecovery(bytes32 hash, bytes sig) returns (bool, address) {
        bytes32 r;
        bytes32 s;
        uint8 v;

        if (sig.length != 65)
          return (false, 0);

        // The signature format is a compact form of:
        //   {bytes32 r}{bytes32 s}{uint8 v}
        // Compact means, uint8 is not padded to 32 bytes.
        assembly {
            r := mload(add(sig, 32))
            s := mload(add(sig, 64))

            // Here we are loading the last 32 bytes. We exploit the fact that
            // 'mload' will pad with zeroes if we overread.
            // There is no 'mload8' to do this, but that would be nicer.
            v := byte(0, mload(add(sig, 96)))

            // Alternative solution:
            // 'byte' is not working due to the Solidity parser, so lets
            // use the second best option, 'and'
            // v := and(mload(add(sig, 65)), 255)
        }

        // albeit non-transactional signatures are not specified by the YP, one would expect it
        // to match the YP range of [27, 28]
        //
        // geth uses [0, 1] and some clients have followed. This might change, see:
        //  https://github.com/ethereum/go-ethereum/issues/2053
        if (v < 27)
          v += 27;

        if (v != 27 && v != 28)
            return (false, 0);

        return safer_ecrecover(hash, v, r, s);
    }

    function ecverify(bytes32 hash, bytes sig, address signer) returns (bool) {
        bool ret;
        address addr;
        (ret, addr) = ecrecovery(hash, sig);
        return ret == true && addr == signer;
    }
}