Exemplo n.º 1
0
def check_pow(
    block_number: int,
    mining_hash: Hash32,
    mix_hash: Hash32,
    nonce: bytes,
    difficulty: int,
) -> None:
    if len(mix_hash) != 32:
        raise ValidationError(f"Wrong length: mix_hash={mix_hash.hex()}")
    elif len(mining_hash) != 32:
        raise ValidationError(f"Wrong length: mining_hash={mining_hash.hex()}")
    elif len(nonce) != 8:
        raise ValidationError(f"Wrong length: nonce={nonce.hex()}")

    cache = get_cache(block_number)
    mining_output = hashimoto_light(block_number, cache, mining_hash,
                                    int.from_bytes(nonce, "big"))

    mix_digest = mining_output[b"mix digest"]

    if mix_digest != mix_hash:
        raise ValidationError(
            f"Invalid POW: expected={mix_digest.hex()}  "
            f"actual={mix_hash.hex()}. "
            f"Mix hash calculated from block #{block_number}, "
            f"mine hash {mining_hash.hex()}, nonce {nonce.hex()}"
            f", difficulty {difficulty}, cache hash {keccak(cache).hex()}")
    result = int.from_bytes(mining_output[b"result"], "big")

    if result > 2**256 // difficulty:
        raise ValidationError(
            f"Insufficient difficulty: actual={result}  required={difficulty}")
def check_pow(block_number: int, mining_hash: Hash32, mix_hash: Hash32,
              nonce: bytes, difficulty: int) -> None:
    cache = get_cache(block_number)  #we get cache by block number

    mining_output = hashimoto_light(
        block_number, cache, mining_hash, big_endian_to_int(
            nonce))  # MISTAKE not int_to_big_endian but the other way around

    #big_endian_to_int(nonce)
    #int_to_big_endian(nonce)) #this is the hashimoto light mining output. It takes block_number, cache, mining_hash, int_to_big_endian(nonce) and hash it

    print("MIX Digest: ", mining_output[b'mix digest'])
    print("MIX HASH:   ", w3.eth.getBlock(block_number).mixHash.hex())

    print("RESULT:    ", mining_output[b'result'])
    print("CONDITION: ", (2**256) // difficulty)

    if mining_output[
            b'mix digest'] != mining_hash:  #this is to say that if the mining digest is not equal to the mix hash, then...
        return False
    elif int_to_big_endian(mining_output[b'result']) <= (
            2**256 // difficulty
    ):  #to convert the result int integer and check if it meets the condition of being less or equal to 2^256 divided by the difficulty
        return False
    else:
        return True  #if it returns true, then all good! We could do more checks but this is enough for now. For additional checks see here https://github.com/ethereum/py-evm/blob/d553bd405bbf41a1da0c227a614baba7b43e9449/eth/consensus/pow.py
Exemplo n.º 3
0
 def hashimoto(
     block_number: int,
     full_size: int,
     cache: Union[List[List[int]], bytes],
     mining_hash: bytes,
     bin_nonce: bytes,
 ):
     return pyethash.hashimoto_light(block_number, cache, mining_hash,
                                     big_endian_to_int(bin_nonce))
Exemplo n.º 4
0
def mine_pow_nonce(block_number: int, mining_hash: Hash32, difficulty: int) -> Tuple[bytes, bytes]:
    cache = get_cache(block_number)
    for nonce in range(MAX_TEST_MINE_ATTEMPTS):
        mining_output = hashimoto_light(block_number, cache, mining_hash, nonce)
        result = big_endian_to_int(mining_output[b'result'])
        result_cap = 2**256 // difficulty
        if result <= result_cap:
            return nonce.to_bytes(8, 'big'), mining_output[b'mix digest']

    raise Exception("Too many attempts at POW mining, giving up")
Exemplo n.º 5
0
def check_pow(block_number, mining_hash, mix_hash, nonce, difficulty):
    validate_length(mix_hash, 32)
    validate_length(mining_hash, 32)
    validate_length(nonce, 8)
    cache = get_cache(block_number)
    mining_output = hashimoto_light(block_number, cache, mining_hash,
                                    big_endian_to_int(nonce))
    if mining_output[b'mix digest'] != mix_hash:
        raise ValidationError("mix hash mistmatch; {0} != {1}".format(
            encode_hex(mining_output[b'mix digest']), encode_hex(mix_hash)))
    result = big_endian_to_int(mining_output[b'result'])
    validate_lte(result, 2**256 // difficulty)
Exemplo n.º 6
0
def check_pow(block_number, mining_hash, mix_hash, nonce, difficulty):
    validate_length(mix_hash, 32, title="Mix Hash")
    validate_length(mining_hash, 32, title="Mining Hash")
    validate_length(nonce, 8, title="POW Nonce")
    cache = get_cache(block_number)
    mining_output = hashimoto_light(
        block_number, cache, mining_hash, big_endian_to_int(nonce))
    if mining_output[b'mix digest'] != mix_hash:
        raise ValidationError("mix hash mismatch; {0} != {1}".format(
            encode_hex(mining_output[b'mix digest']), encode_hex(mix_hash)))
    result = big_endian_to_int(mining_output[b'result'])
    validate_lte(result, 2**256 // difficulty, title="POW Difficulty")
Exemplo n.º 7
0
def check_pow(block_number: int, mining_hash: Hash32, mix_hash: Hash32,
              nonce: bytes, difficulty: int) -> None:
    validate_length(mix_hash, 32, title="Mix Hash")
    validate_length(mining_hash, 32, title="Mining Hash")
    validate_length(nonce, 8, title="POW Nonce")
    cache = get_cache(block_number)
    mining_output = hashimoto_light(block_number, cache, mining_hash,
                                    big_endian_to_int(nonce))
    if mining_output[b'mix digest'] != mix_hash:
        raise ValidationError("mix hash mismatch; {0} != {1}".format(
            encode_hex(mining_output[b'mix digest']), encode_hex(mix_hash)))
    result = big_endian_to_int(mining_output[b'result'])
    validate_lte(result, 2**256 // difficulty, title="POW Difficulty")
Exemplo n.º 8
0
def test_light_and_full_agree():
    cache = pyethash.mkcache_bytes(1024, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
    full_size = 1024 * 32
    header = "~~~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~"
    light_result = pyethash.hashimoto_light(full_size, cache, header, 0)
    dataset = pyethash.calc_dataset_bytes(full_size, cache)
    full_result = pyethash.hashimoto_full(dataset, header, 0)
    assert light_result["mix digest"] != None
    assert len(light_result["mix digest"]) == 32
    assert light_result["mix digest"] == full_result["mix digest"]
    assert light_result["result"] != None
    assert len(light_result["result"]) == 32
    assert light_result["result"] == full_result["result"]
Exemplo n.º 9
0
def test_light_and_full_agree():
    cache = pyethash.mkcache_bytes(
              1024,
              "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
    full_size = 1024 * 32
    header = "~~~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~"
    light_result = pyethash.hashimoto_light(full_size, cache, header, 0)
    dataset = pyethash.calc_dataset_bytes(full_size, cache)
    full_result = pyethash.hashimoto_full(dataset, header, 0)
    assert light_result["mix digest"] != None
    assert len(light_result["mix digest"]) == 32
    assert light_result["mix digest"] == full_result["mix digest"]
    assert light_result["result"] != None
    assert len(light_result["result"]) == 32
    assert light_result["result"] == full_result["result"]
Exemplo n.º 10
0
def mine_pow_nonce(block_number: int, mining_hash: Hash32,
                   difficulty: int) -> Tuple[bytes, bytes]:
    cache = get_cache(block_number)
    # VDF input
    mining_input = hashimoto_light(block_number, cache, mining_hash)
    vdf_input_integer = big_endian_to_int(mining_input[b'result'])

    # Calculate VDF Steps needed.

    # Adding VRF (WIP)
    node_vrf_seed_b64 = self.vrf.get_seed_b64(vdf_input_integer)

    vdf_steps = hashimoto_light(DEFAULT_DEBUG_STAKE, TOTAL_COINS,
                                node_vrf_seed_b64)
    vdf_difficulty = big_endian_to_int(vdf_steps[b'result'])
    print('VDF Difficulty = %d' % vdf_difficulty)

    print("DEBUG: Mining sequential VDF (Sloth) ...")
    # nonce = vdf_execute(vdf_input_integer,node_vdf_steps) # VRF version
    nonce = vdf_execute(vdf_input_integer, vdf_difficulty)
    print("DEBUG: Generated NONCE = %d" % nonce)

    return nonce, node_vrf_seed_b64, self.vrf.get_pem_public_key(
    )  # , node_vrf_seed # with this
Exemplo n.º 11
0
def check_pow(block_number: int, mining_hash: Hash32, mix_hash: Hash32,
              nonce: bytes, difficulty: int) -> None:
    validate_length(mix_hash, 32, title="Mix Hash")
    validate_length(mining_hash, 32, title="Mining Hash")
    validate_length(nonce, 8, title="POW Nonce")
    cache = get_cache(block_number)
    mining_output = hashimoto_light(block_number, cache, mining_hash,
                                    big_endian_to_int(nonce))
    if mining_output[b'mix digest'] != mix_hash:
        raise ValidationError(
            f"mix hash mismatch; expected: {encode_hex(mining_output[b'mix digest'])} "
            f"!= actual: {encode_hex(mix_hash)}. "
            f"Mix hash calculated from block #{block_number}, "
            f"mine hash {encode_hex(mining_hash)}, nonce {encode_hex(nonce)}"
            f", difficulty {difficulty}, cache hash {encode_hex(keccak(cache))}"
        )
    result = big_endian_to_int(mining_output[b'result'])
    validate_lte(result, 2**256 // difficulty, title="POW Difficulty")
Exemplo n.º 12
0
    from repoze.lru import lru_cache
else:
    ETHASH_LIB = 'ethash'
    from functools import lru_cache


if ETHASH_LIB == 'ethash':
    mkcache = ethash.mkcache
    EPOCH_LENGTH = ethash_utils.EPOCH_LENGTH
    hashimoto_light = ethash.hashimoto_light
elif ETHASH_LIB == 'pyethash':
    import pyethash
    mkcache = pyethash.mkcache_bytes
    EPOCH_LENGTH = pyethash.EPOCH_LENGTH
    hashimoto_light = lambda s, c, h, n: \
        pyethash.hashimoto_light(s, c, h, utils.big_endian_to_int(n))
else:
    raise Exception("invalid ethash library set")

TT64M1 = 2**64 - 1
cache_seeds = ['\x00' * 32]
cache_by_seed = OrderedDict()
cache_by_seed.max_items = 10


def get_cache(block_number):
    while len(cache_seeds) <= block_number // EPOCH_LENGTH:
        cache_seeds.append(sha3.sha3_256(cache_seeds[-1]).digest())
    seed = cache_seeds[block_number // EPOCH_LENGTH]
    if seed in cache_by_seed:
        c = cache_by_seed.pop(seed)  # pop and append at end
Exemplo n.º 13
0
    def hashimoto_light(s, c, h, n):        return \
pyethash.hashimoto_light(s, c, h, utils.big_endian_to_int(n))
else:
Exemplo n.º 14
0
def pow_hash(block_number, header, nonce) -> Tuple[bytes, bytes]:
    """search for hash result using hashimoto_light."""
    cache_bytes = get_cache(block_number)
    hash_ret = hashimoto_light(block_number, cache_bytes, header, nonce)
    return hash_ret[b"mix digest"], hash_ret[b"result"]