Consensus Proofs

Consensus in Distributed Systems

Liveness

Safety

Byzantine Attacks

Only those you trust can betray you. - Terry Goodkind

51% Attacks

Even if there’s a perfect ZK-SNARK-based bridge that fully validates consensus, it’s still vulnerable to theft through 51% attacks.

Eclipse Attacks

Long Range Attacks

Data Withholding Attacks

Byzantine Fault Tolerance

Optimistic Bridging

/// A signature from a member of the validator set over the latest header.
type Signature = Vec<u8>;

/// Signatures from a super-majority subset of the full authority set.
type ConsensusProof = Vec<Signature>;

/// Typical block header, different blockchains may add more chain specific
/// metadata, but this is all we need for our consensus client.
struct Header {
	/// commitment to the full blockchain state
	state_root: H256,
	/// hash of the parent header
	parent_hash: H256,
	/// height of this block
	block_number: u64,
	/// commitment to the transactions in this block.
	transactions_root: H256,
}

/// This is used to advance the consensus client's view of the netwok.
struct ConsensusUpdate {
  /// The latest finalized header.
  header: Header,
	/// A list of signatures from members of the authority set over the header 
  proof: ConsensusProof,
}

/// Holds the full transaction data
struct Block {
	/// Block header
	header: Header,
	/// Transaction list
	transactions: Vec<Vec<u8>>,
}

/// Holds the block as well as the state proof needed to
/// re-execute the block.
struct BlockProof {
  /// Full block data
  block: Block,
	/// State proof for parts of the state modified by the transactions.
	/// This is just a list of merkle-patricia nodes touched by the transactions.
	/// Also called state witness or proof-of-validity.
	state_proof: Vec<Vec<u8>>
}

/// This allows us to detect all the different kinds of byzantine attacks
/// that consensus clients are vulnerable to.
enum FraudProof {
	/// An equivocation report allows us to detect both eclipse attacks and
	/// 51% attacks.
  Equivocation {
		/// The first header with proof
		first: ConsensusUpdate,
		/// The second conflicting header with proof
		second: ConsensusUpdate,
	},
	/// A Fisherman can report that the data behind some header doesn't exist
	/// The relayer that submitted the header needs make the data available or
	/// risk losing their stake.
	DataWithholdingChallenge(Header),
	/// The relayer has made the full block available,
	/// false reports are liable to get slashed.
	DataAvailable(BlockProof)
}

/// A byzantine fault tolerant consensus client.
trait ConsensusClient {
	/// Called by the relayers to submit new consensus updates.
	fn process_consensus_proof(update: ConsensusUpdate);

	/// Called by the fishermen to report byzantine attacks.
	fn process_fraud_proof(proof: FraudProof);
}

Fraud Proofs

Fishermen

Unstaking Periods

Summary

References