Client should not require Block hash to be H256 for everything useful

[rphmeier]

This pollutes everything.

When we need to use hashes as keys on disk, I think it would be fine to truncate hashes to 256 bits silently and internally (as that is more than enough entropy), but not to require it as a type parameter everywhere.

[rphmeier]

@andresilva pointed out that somewhere we need a bound proving that Backend::Hasher::Out == Block::Hash.

We should aim to make this more flexible with some kind of conversion parameter or drop the requirement entirely.

[burdges]

I'm confused.. Isn't H256 exactly what avoid the type parameter everywhere?

[bkchr]

@burdges This line

substrate/core/client/src/client.rs

Line 301 in 203e2c2

Block: BlockT<Hash=H256>,

is the one that should be dropped.

[rphmeier]

Well, I suppose in some sense it's avoiding a concrete specification of the hash algorithm, but Substrate in some places says "we're generic over the hash output length" and in most (important places) it says "the hash length must be 256 bits".

[burdges]

I see.. We need 256 bit hashes for 128 bits of security anyplace where birthday attacks pose a threat, like in Merkle trees. We can safely neglect that we technically loose some security bits from the Merkle tree itself, so we do not afaik require more than 256 bits anyplace.

As an aside, if we identify places that only require fewer bits of security, like MACs, then we could make them use some MacTag128 or H192 types, but right I think being generic over hash size everywhere seems unnecessary.

[rphmeier]

It should either be fully-generic or fully-non-generic, not some weird halfway-house.

[burdges]

I'm saying non-generic H256 is always fine. :)

[rphmeier]

Right - and just to clarify, any cryptographic non-safety caused by too-small hashes is not something that would arise as part of the implementation of this issue. That would happen in the chain configuration, where somebody might choose a hash size which is too small.

[Demi-Marie]

IMO, a better option would be to have a type SubstrateHash = H256 and then use SubstrateHash everywhere. That way, we can still change the type if we need to.