onionrblocks/onionrblocks/generators/anonvdf.py

import time
from binascii import a2b_hex

from kasten import Kasten, generator
from kasten.types import KastenPacked, KastenChecksum
from kasten.exceptions import InvalidID

from mimcvdf import vdf_create, vdf_verify

from onionrblocks.universalrules import check_block_sanity


class NotEnoughRounds(Exception):
    pass

class NoTTLSet(Exception):
    pass

class RoundsOutOfBounds(Exception):
    pass

MAX_ROUNDS = 999_999_999
MINIMUM_ROUNDS = 10_000


class AnonVDFGenerator(generator.KastenBaseGenerator):

    # 90000 rounds = 1 second (2.8ghz C) = 1 hour storage of 1 MB storage
    # jan 2021 disk price metric = 0.000017 USD per MB
    # mobile MB transfer US/Canada = 0.0125 USD
    # Max cost of block storage + American mobile data transfer = 0.0751 USD
    # Goal: approximately 2 seconds of computation for 1 hour of 1 MB storage

    byte_cost = 10
    second_cost = 4

    @classmethod
    def get_rounds_for_ttl_seconds(cls, seconds: int, size_bytes: int):
        return (seconds * cls.second_cost) + (size_bytes * cls.byte_cost)

    @classmethod
    def get_ttl_seconds_per_rounds(cls, rounds: int, size_bytes: int):
        return (rounds - (size_bytes * cls.byte_cost)) // cls.second_cost

    @classmethod
    def generate(
            cls, packed_bytes: KastenPacked, ttl: int = None) -> Kasten:

        k: Kasten = Kasten(
                    None,
                    packed_bytes, None,
                    auto_check_generator=False)
        try:
            ttl: int = k.get_metadata()['ttl']
        except (KeyError, TypeError) as e:
            raise NoTTLSet(e)

        rounds = AnonVDFGenerator.get_rounds_for_ttl_seconds(ttl, len(packed_bytes))

        if rounds > MAX_ROUNDS or rounds < MINIMUM_ROUNDS:
            raise RoundsOutOfBounds()

        check_block_sanity(packed_bytes)
        vdf = vdf_create(
                packed_bytes,
                rounds, dec=True
                ).to_bytes(64, "big")
        return Kasten(vdf, packed_bytes, cls, auto_check_generator=False)

    @staticmethod
    def validate_id(
            hash: KastenChecksum,
            packed_bytes: KastenPacked) -> None:

        check_block_sanity(packed_bytes)
        k: Kasten = Kasten(
                    None,
                    packed_bytes, None,
                    auto_check_generator=False)
        try:
            ttl: int = k.get_metadata()['ttl']
        except (KeyError, TypeError) as e:
            raise NoTTLSet(e)

        ttl = int(ttl)
        rounds = AnonVDFGenerator.get_rounds_for_ttl_seconds(ttl, len(packed_bytes))
        if rounds > MAX_ROUNDS or rounds < MINIMUM_ROUNDS:
            raise RoundsOutOfBounds()


        #hash = hash.lstrip(b"0")
        hash = int(hash, 16)

        try:
            hash = int.from_bytes(hash, byteorder="big")
        except TypeError:
            pass
        if not vdf_verify(packed_bytes, hash, rounds):
            raise InvalidID

        test_obj = Kasten(
            None, packed_bytes, None, auto_check_generator=False)
        allowed_age_seconds = AnonVDFGenerator.get_ttl_seconds_per_rounds(
            rounds, len(packed_bytes))
        if time.time() > test_obj.get_timestamp() + allowed_age_seconds:
            raise ValueError(
                f"Block rounds only valid through {allowed_age_seconds}")

        return None