# minimum and maximum block time

If you've ever seen the ethereum blocktime chart, you've noticed that always it's between 10-19 and when ever it comes bigger than, network will set difficulty lower than before and again the block time is between 10 and 19. Is there any config in genesis or somewhere to set this time?

@RomanFrolov's answer is good; because my extension doesn't easily fit in a comment, I'm adding it as another answer.

There is no such thing as a minimum or maximum block time. There is a target time and a difficulty adjusting algorithm (as described by @RomanFrolov) that attempts to maintain the target time. Note sure where your 10-19s comes from because the normal range is actually a fair bit larger, unless you're looking at averages over longer periods of time. The mining of a block is a probabilistic event that can is described by a Poisson distribution. We can see from a Poisson table that the probability of having more than zero blocks after 10.5s (70% of the current target block time) is `1 - 0.4966`, or about 50%. The probability of no blocks for 21 seconds (140% of the current target block time) is 0.2466 -- or about 25%.

When you're looking at averages of larger sets, you can see, for example lambda=15 (225s) that, suddenly, the probability of seeing fewer than 11 blocks in that period (for an average block time of 20s) is about 10% (which is less probably than we found for single blocks at 21s). Similarly, the odds of finding more than 22 (10s average block time) is `1 - 0.9673` -- or about 3%. If you take the average block time for every 100 blocks, the range quickly converges to 15s and the 95% interval shrinks to what you observe.

TL;DR First, you set difficulty in genesis. Then, you calculate difficulty when you init your block from parent.

P.S: I highly suggest `ctrl+F` difficulty

## 1. Set difficulty in genesis

``````def genesis(env, **kwargs):
assert isinstance(env, Env)
"""Build the genesis block."""
allowed_args = set(['start_alloc', 'prevhash', 'coinbase', 'difficulty', 'gas_limit',
'timestamp', 'extra_data', 'mixhash', 'nonce'])
assert set(kwargs.keys()).issubset(allowed_args)

start_alloc = kwargs.get('start_alloc', env.config['GENESIS_INITIAL_ALLOC'])
prevhash=kwargs.get('prevhash', env.config['GENESIS_PREVHASH']),
uncles_hash=utils.sha3(rlp.encode([])),
coinbase=kwargs.get('coinbase', env.config['GENESIS_COINBASE']),
state_root=trie.BLANK_ROOT,
tx_list_root=trie.BLANK_ROOT,
receipts_root=trie.BLANK_ROOT,
bloom=0,
difficulty=kwargs.get('difficulty', env.config['GENESIS_DIFFICULTY']),
number=0,
gas_limit=kwargs.get('gas_limit', env.config['GENESIS_GAS_LIMIT']),
gas_used=0,
timestamp=kwargs.get('timestamp', 0),
extra_data=kwargs.get('extra_data', env.config['GENESIS_EXTRA_DATA']),
mixhash=kwargs.get('mixhash', env.config['GENESIS_MIXHASH']),
nonce=kwargs.get('nonce', env.config['GENESIS_NONCE']),
)
block = Block(header, [], [], env=env)
if 'wei' in data:
if 'balance' in data:
if 'code' in data:
if 'nonce' in data:
if 'storage' in data:
for k, v in data['storage'].items():
utils.big_endian_to_int(decode_hex(v[2:])))
block.commit_state()
block.state.db.commit()
# genesis block has predefined state root (so no additional finalization
# necessary)
return block
``````

## 2. Calculate difficulty when you init new block

`````` @classmethod
def init_from_parent(cls, parent, coinbase, nonce=b'', extra_data=b'',
timestamp=int(time.time()), uncles=[], env=None):
"""Create a new block based on a parent block.
The block will not include any transactions and will not be finalized.
"""
uncles_hash=utils.sha3(rlp.encode(uncles)),
coinbase=coinbase,
state_root=parent.state_root,
tx_list_root=trie.BLANK_ROOT,
receipts_root=trie.BLANK_ROOT,
bloom=0,
difficulty=calc_difficulty(parent, timestamp),
mixhash='',
number=parent.number + 1,
gas_limit=calc_gaslimit(parent),
gas_used=0,
timestamp=timestamp,
extra_data=extra_data,
nonce=nonce)
block = Block(header, [], uncles, env=env or parent.env,
parent=parent, making=True)
block.ancestor_hashes = [parent.hash] + parent.ancestor_hashes
block.log_listeners = parent.log_listeners
return block
``````

``````def calc_difficulty(parent, timestamp):
config = parent.config
offset = parent.difficulty // config['BLOCK_DIFF_FACTOR']
if parent.number >= (config['HOMESTEAD_FORK_BLKNUM'] - 1):
sign = max(1 - 2 * ((timestamp - parent.timestamp) //
else:
sign = 1 if timestamp - parent.timestamp <
# If we enter a special mode where the genesis difficulty starts off
below
# the minimal difficulty, we allow low-difficulty blocks (this will never
# happen in the official protocol)
o = int(max(parent.difficulty + offset * sign, min(parent.difficulty,
config['MIN_DIFF'])))
period_count = (parent.number + 1) // config['EXPDIFF_PERIOD']
if period_count >= config['EXPDIFF_FREE_PERIODS']:
o = max(o + 2**(period_count - config['EXPDIFF_FREE_PERIODS']),
config['MIN_DIFF'])
return o
``````