6DVT in the protocol PLANNED

Reading notes on absorbing distributed validators into the protocol — m-of-n without splitting keys, plus what it makes buildable.

Read-only design analysis — no wallet needed. Start with the two diagrams contrasting DVT today against the proposal.

Why

Reading a live protocol-design discussion closely enough to separate three things people usually blur: what the proposal actually changes, what it leaves unresolved, and which parts of the idea can be built one layer up without waiting for it. It is also a second instance of a pattern this site already documents elsewhere — middleware doing a job well until the protocol absorbs it, which is exactly what ERC-4337 bundlers face from native account abstraction.

How it works

Today's DVT (Obol, SSV) splits one validator key with Shamir sharing or threshold BLS and runs an off-chain consensus round to reassemble a signature each time; the protocol still sees a single validator, and all distribution lives in middleware. The proposal never splits the key: each participant registers their own (n ≤ 16), the protocol groups them m-of-n, and BLS aggregation plus a participation bitfield — the same grammar as today's attestation aggregation — decides whether enough took part. That removes both the per-signature consensus round and the DKG ceremony, and it is only possible because EIP-7251 raised the max effective balance so that 32·n ETH standing up n slots is arithmetic the protocol can do internally. The page is explicit that this is an ethresear.ch-stage discussion with no assigned EIP number, lists the four questions it leaves open (slashing attribution, latency budget, the m<n collusion trade-off, the n ≤ 16 rationale), and separates PoC candidates into those buildable today at the application layer and those that genuinely wait on adoption.

2 diagram(s) on the live page.

Related code

# DVT in the protocol — the proposal never splits one validator key (unlike today's
# Obol/SSV, which Shamir-splits a key and reassembles a signature via off-chain
# consensus). Instead each of n participants keeps their own key; the protocol groups
# them m-of-n and a participation bitfield (mocked BLS aggregation) decides if enough
# signed — the same grammar as today's attestation aggregation.

import hashlib
from dataclasses import dataclass


@dataclass
class Participant:
    operator_id: str
    private_key: str  # each operator's own key — never shared or split

    def sign(self, message: str) -> str:
        # Mock signature: a real BLS sig would be a curve point; a hash stands in.
        return hashlib.sha256((self.private_key + message).encode()).hexdigest()[:16]


def bls_aggregate(signatures: list[str]) -> str:
    """Mock aggregation: real BLS sums curve points into one constant-size signature."""
    combined = "".join(sorted(signatures))
    return hashlib.sha256(combined.encode()).hexdigest()[:16]


def protocol_check(n: int, m_threshold: int, signed_by: list[Participant], message: str) -> dict:
    """The protocol groups n registered operators m-of-n and checks the bitfield."""
    bitfield = [1 if p in signed_by else 0 for p in OPERATORS[:n]]
    aggregate_sig = bls_aggregate([p.sign(message) for p in signed_by])
    quorum_met = sum(bitfield) >= m_threshold
    return {
        "bitfield": bitfield,
        "participants_signed": sum(bitfield),
        "threshold": m_threshold,
        "quorum_met": quorum_met,
        "aggregate_signature": aggregate_sig if quorum_met else None,
    }


OPERATORS = [Participant(f"operator-{i}", private_key=f"sk-{i}") for i in range(1, 6)]  # n = 5

if __name__ == "__main__":
    print("DVT absorbed into the protocol — separate keys, m-of-n grouping, participation bitfield\n")

    n, m = 5, 3
    message = "attest(slot=1234)"

    print(f"n={n} registered operators, m={m} required to reach quorum\n")

    # Only 3 of 5 operators actually sign this round.
    signers = OPERATORS[:3]
    result = protocol_check(n, m, signers, message)
    print(f"Signers this round: {[p.operator_id for p in signers]}")
    print(f"Participation bitfield: {result['bitfield']}")
    print(f"Signed {result['participants_signed']}/{n}, threshold {result['threshold']} "
          f"-> quorum_met={result['quorum_met']}")
    print(f"Aggregate signature: {result['aggregate_signature']}\n")

    # Below threshold: only 2 sign.
    signers = OPERATORS[:2]
    result = protocol_check(n, m, signers, message)
    print(f"Signers this round: {[p.operator_id for p in signers]}")
    print(f"Participation bitfield: {result['bitfield']}")
    print(f"Signed {result['participants_signed']}/{n}, threshold {result['threshold']} "
          f"-> quorum_met={result['quorum_met']}")
    print("No aggregate signature: quorum not reached.")

docs/code/pocs/dvt.py

Open on jaylabs.xyz →

한국어

6프로토콜에 흡수된 DVT PLANNED

분산 밸리데이터를 프로토콜이 직접 다루자는 제안 정독 노트 — 키를 쪼개지 않는 m-of-n, 그리고 그것이 만들어내는 것들.

읽기 전용 설계 분석 — 지갑 불필요. 오늘의 DVT와 제안을 대비시킨 다이어그램 두 장부터 보세요.

왜

진행 중인 프로토콜 설계 논의를, 사람들이 흔히 뭉뚱그리는 세 가지를 분리할 만큼 자세히 읽는 작업입니다: 제안이 실제로 바꾸는 것, 미해결로 남긴 것, 그리고 제안을 기다리지 않고 한 층 위에서 지금 만들 수 있는 부분. 이 사이트가 이미 다른 곳에서 기록하고 있는 패턴의 두 번째 사례이기도 합니다 — 미들웨어가 어떤 일을 잘 해내다가 프로토콜에 흡수되는 흐름으로, ERC-4337 번들러가 네이티브 계정 추상화 앞에서 맞고 있는 상황과 같습니다.

동작 방식

오늘의 DVT(Obol·SSV)는 하나의 밸리데이터 키를 샤미르 분할이나 임계 BLS로 쪼갠 뒤, 서명이 필요할 때마다 오프체인 합의 라운드로 재조립합니다 — 프로토콜은 여전히 밸리데이터 하나만 보고, 분산은 전부 미들웨어에 삽니다. 제안은 키를 쪼개지 않습니다: 각 참여자가 자기 키를 등록하고(n ≤ 16), 프로토콜이 m-of-n으로 묶으며, BLS 집계와 참여 비트필드(오늘날 attestation 집계와 같은 문법)로 충분한 인원이 참여했는지 판정합니다. 이로써 서명마다의 합의 라운드와 DKG 세리머니가 함께 사라지고, 이것이 가능한 이유는 EIP-7251이 유효 잔고 상한을 올려 32·n ETH가 n개 슬롯을 세운다는 산수를 프로토콜이 내부적으로 할 수 있게 되었기 때문입니다. 페이지는 이것이 EIP 번호가 없는 ethresear.ch 단계의 논의임을 명시하고, 미해결로 남은 질문 넷(슬래싱 귀속, 지연 예산, m<n 공모 트레이드오프, n ≤ 16의 근거)을 나열하며, PoC 후보를 애플리케이션 계층에서 지금 만들 수 있는 것과 실제로 채택을 기다려야 하는 것으로 구분합니다.

2 diagram(s) on the live page.

관련 코드

# DVT in the protocol — the proposal never splits one validator key (unlike today's
# Obol/SSV, which Shamir-splits a key and reassembles a signature via off-chain
# consensus). Instead each of n participants keeps their own key; the protocol groups
# them m-of-n and a participation bitfield (mocked BLS aggregation) decides if enough
# signed — the same grammar as today's attestation aggregation.

import hashlib
from dataclasses import dataclass


@dataclass
class Participant:
    operator_id: str
    private_key: str  # each operator's own key — never shared or split

    def sign(self, message: str) -> str:
        # Mock signature: a real BLS sig would be a curve point; a hash stands in.
        return hashlib.sha256((self.private_key + message).encode()).hexdigest()[:16]


def bls_aggregate(signatures: list[str]) -> str:
    """Mock aggregation: real BLS sums curve points into one constant-size signature."""
    combined = "".join(sorted(signatures))
    return hashlib.sha256(combined.encode()).hexdigest()[:16]


def protocol_check(n: int, m_threshold: int, signed_by: list[Participant], message: str) -> dict:
    """The protocol groups n registered operators m-of-n and checks the bitfield."""
    bitfield = [1 if p in signed_by else 0 for p in OPERATORS[:n]]
    aggregate_sig = bls_aggregate([p.sign(message) for p in signed_by])
    quorum_met = sum(bitfield) >= m_threshold
    return {
        "bitfield": bitfield,
        "participants_signed": sum(bitfield),
        "threshold": m_threshold,
        "quorum_met": quorum_met,
        "aggregate_signature": aggregate_sig if quorum_met else None,
    }


OPERATORS = [Participant(f"operator-{i}", private_key=f"sk-{i}") for i in range(1, 6)]  # n = 5

if __name__ == "__main__":
    print("DVT absorbed into the protocol — separate keys, m-of-n grouping, participation bitfield\n")

    n, m = 5, 3
    message = "attest(slot=1234)"

    print(f"n={n} registered operators, m={m} required to reach quorum\n")

    # Only 3 of 5 operators actually sign this round.
    signers = OPERATORS[:3]
    result = protocol_check(n, m, signers, message)
    print(f"Signers this round: {[p.operator_id for p in signers]}")
    print(f"Participation bitfield: {result['bitfield']}")
    print(f"Signed {result['participants_signed']}/{n}, threshold {result['threshold']} "
          f"-> quorum_met={result['quorum_met']}")
    print(f"Aggregate signature: {result['aggregate_signature']}\n")

    # Below threshold: only 2 sign.
    signers = OPERATORS[:2]
    result = protocol_check(n, m, signers, message)
    print(f"Signers this round: {[p.operator_id for p in signers]}")
    print(f"Participation bitfield: {result['bitfield']}")
    print(f"Signed {result['participants_signed']}/{n}, threshold {result['threshold']} "
          f"-> quorum_met={result['quorum_met']}")
    print("No aggregate signature: quorum not reached.")

docs/code/pocs/dvt.py

Open on jaylabs.xyz →