betaFeedback

WorksComputer Science

Cambium: Participant-Built Commitment Roots for Shared Digital Infrastructure

Abstract

Commitment services, such as timestamping, transparency logs and provenance registries, let a party prove that it bound itself to a record without publishing the record. Today an operator runs them, or a blockchain replaces the operator at the cost of network-wide agreement on every write. We present Cambium, a permissioned peer-to-peer service in which participants build each cycle's commitment root together, so that no single party decides which inputs the root includes. Fixed-size committees certify inputs and use a recursive-doubling merge, in which disjoint groups recompute every intermediate value, to spread root construction across all participants. A successful cycle costs each node O(clog⁡(n/c))O(c\log(n/c)) messages for committee size cc, and each node stores its own O(log⁡(n/c))O(\log(n/c)) proof per cycle, along with the O(n)O(n) membership roster. A Go prototype on AWS with c=4c=4, 8-256 nodes and simulated stragglers completes cycles in 12-148 ms and verifies proofs in under 1.5 ms, and demonstrates logarithmic growth. We show that conflicting certificates identify their signers, that a proof binds a signed input to its root, and that two conflicting roots both become final only if at least a third of the nodes are Byzantine, except with probability exponentially small in the number of committees. We also set out the membership, proof-availability and exclusion questions a community deploying Cambium must answer.

Introduction

Many digital interactions need a commitment rather than a ledger: evidence that a party bound itself to a record at a given point, which it cannot later disown and which others can check. A cooperative registering dataset contributions, a newsroom committing to a photograph’s hash at capture, and an agent committing to an offer before a counterparty acts all need that evidence across organisations. None needs a total order over every action. Nor do the records need to live in one place: local-first software [13] and per-agent ledgers such as TrustChain [19] keep records with their participants, who disclose a record and its proof only when needed.

Overview and Scope

We write nn for a participating computer, nn for the number of nodes and cc for the committee size. Every node holds the roster, the list of all members’ identities and public keys, which the genesis root CR0CR_0 fixes and only signed membership epochs change (§5, §8).

In each cycle every node submits one input, a digest, and committees of cc nodes certify these inputs (§4) before all nodes jointly compute a cycle root over them. Each root commits to its predecessor, so the roots a node accepts form a hash chain. We want five properties: conflicting certificates identify their signers (accountability); a proof verifies against a root only if its input was certified for that root (proof soundness); an accepted root omits at most a fixed share of the committees, set by Hmax⁡H_{\max}, and counts each omission as a hole (§4); honest nodes never hold conflicting final roots (finality); and a node’s per-cycle cost does not grow with the length of the chain. Section 5 establishes the first two, and the fourth, while fewer than a third of nodes are Byzantine, with high probability; the acceptance rule and cost bounds of §4 give the third and fifth. A node exposes four operations: submit an input for a future cycle, export a proof, verify a proof against a root, and report the root it accepts for a cycle and whether that root is final.

Use case. Consider news organisations that commit to photographs’ hashes at capture, so that a fact-checker can later confirm that a photograph existed, unaltered, by a given cycle. The participants are hundreds to thousands of organisations, each running one node that batches its photographers’ captures. They need commitment within about a minute, any number of commitments per cycle, tolerance of members going offline, and rare roster changes. With c=16c = 16 Cambium tolerates 5% of members offline, and with c=32c = 32, 10% (Table 2); more slows progress but does not affect safety. A newsroom node submits the root of its local Merkle batch (POST /commit); at publication it exports a proof for that cycle with the photograph’s batch-inclusion claim (GET /path). A fact-checker checks the committee signatures, recomputes the cycle root (POST /verifyProof), and compares it with the final root that most of several randomly chosen members report (GET /root).

cc2%5%10%15%20%
1640 (40)37 (35)0 (0)——
32—40 (40)36 (35)0 (1)—
64——40 (40)38 (39)3 (9)

Table 2. Simulated cycles (n=4,096n = 4,096, 40 per cell) in which every live node finishes on the same root, by committee size and share of crashed nodes, with the first-order model’s prediction in parentheses. — marks cells not run.

What a proof establishes. A proof binds a signed digest to a cycle root and a key, without attesting to the record’s truth or the key’s authority. The cycle does not establish wall-clock time, and guessable records need a salted digest H(r∥x)H(r\mathbin\Vert x) with fresh rr. After rollback (§ 2), proofs against a discarded root no longer verify, and holders must re-submit. A proof against a root outside the chain the verifier trusts provides no evidence about the claim.

Batching and absence. A complete committee packet shows that a digest is absent from that packet. A claim that a node made no conflicting commitment over a range of cycles additionally needs a namespace, a rule for unique submissions, and the complete batches for those cycles. A hole (§ 2) establishes neither an empty input nor the absence of an action. There is no globally readable ledger, and each node keeps the O(n)O(n) roster, this storage cost is the main non-logarithmic growth factor in Cambium.

Data Structures

Cycle trie

A Merkle tree over the committees’ packets yields a root, but if a few nodes compute its upper levels they control it, and if every node computes every level, every node receives every packet. Cambium instead follows recursive-doubling all-reduce [23]: at each level, distinct values halve as their holders double, so after log⁡2(n/c)\log_2(n/c) levels every node holds the root. To tolerate faulty nodes, nodes act in groups of cc, and a node accepts a value only when a quorum of a group vouches for it. The group assignment below ensures that every level-ll value is recomputed by 2l2^l disjoint groups, so a captured group causes divergence that later cycles can expose (§ 2); that each node contacts O(c)O(c) others per level; and that a node’s co-members change across levels, decorrelating the recomputations (Figure 1).

Group layout and cycle-root construction

Figure 1. Group layout and cycle-root construction. Left: an illustrative cycle with n=64n = 64, c=8c = 8 and three merge levels. Right: signed committee packets merge into CRtCR_t; the image’s kk is LL.

Let n=c⋅2Ln = c \cdot2^L with cc a power of two; other roster sizes need padding or unequal committees, which we do not analyse. Each node has a cycle index ii (§ 1.2). At level l∈{0,…,L}l \in\{0,\ldots,L\}, where level 0 is the committee and merges occur at levels 1 to LL, the low ll bits of ii give its default group q=i mod 2lq = i \bmod2^l, the next k=log⁡2ck = \log_2 c bits give its position j=⌊i/2l⌋ mod cj = \lfloor i/2^l\rfloor\bmod c, and the high bits give its stack. Its group is

group⁡(i,l)=(q−ol[j]) mod 2l,(1)\operatorname{group}(i,l) = (q - o_l[j]) \bmod2^l, \tag*{(1)}

where olo_l is a fixed table of integer offsets. A level-ll stack is the c⋅2lc \cdot2^l nodes that share the high bits; it holds 2l2^l groups of cc nodes, one per position, and every group in a stack computes the same value. At level 0, q=0q = 0 and each stack is one committee of cc consecutive indices. Moving up a level shifts the position field up one bit, halving the number of stacks and doubling their depth. For example, with n=16n = 16, c=4c = 4 and the prototype’s diagonal offsets ol[j]=j mod 2lo_l[j] = j \bmod2^l, node 6 is in committee {4,…,7}\{4,\ldots,7\} at level 0, in group {1,2,5,6}\{1,2,5,6\} of stack {0,…,7}\{0,\ldots,7\} at level 1, and in group {1,6,11,12}\{1,6,11,12\} at level 2.

The offsets permute membership within a stack, so root and proof validity do not depend on olo_l; agreement does, since olo_l sets how often two nodes share a group across levels. Choosing olo_l is a combinatorial design problem we treat separately.

Banyan trie

After each cycle, a small-domain pseudorandom permutation [21], keyed by the locally accepted root, maps identity indices to next-cycle indices. This re-seats committees; assignment is unknowable until the preceding root exists. Every packet carries its predecessor root, linking successive cycle tries into the banyan trie. Re-seating also samples global health: nodes that built on different predecessor roots can meet in the next cycle’s committees, where a node can join, as a dissenter, a committee that a foreign root’s assignment places it in (§ 2).

Cycle Protocol

Committee phase. A committee must turn its members’ inputs into one packet signed by τ=⌈2c/3⌉\tau= \lceil2c/3\rceil members, so that its certificate is unique (Lemma 5.1). Members first exchange signed initial packets carrying the cycle number, sender identity, cycle index, predecessor root and a hash of the sender’s input. Two rounds follow. In the hash round members agree on which input hashes the packet includes; this fixes the inputs before anyone reveals them, so no member can choose its input after seeing others’1. In the data round they reveal the inputs and agree on the committee signed packet (CSP), the leaf of the cycle trie. Each round runs a single-slot PBFT-style agreement [4] with bounded view changes; a commit certificate contains τ\tau member signatures. Without view changes, its O(c2)O(c^2) messages cost each node O(c)O(c); committee designs without agreement are future work. A committee that cannot decide within the view-change bound contributes a hole of weight cc, its keys; a hole is a fixed string, so all groups hash it alike.

Merge phase. At each merge level, a node combines the value of its own side, which it already holds, with the value of the sibling side, which it must learn from nodes that hold it. At level-ll stack ss is formed from level-(l−1)(l-1) stacks $2s$ and 2s+12s+1. At merge level ll, a node’s peers are the other members of its level-(l−1)(l-1) group, which hold its side’s value, and its allies are the group with the same group number in the sibling level-$(l-1) stack, which hold the other side’s value; the relation is symmetric, and both sets follow from Eq. (1) and the roster. In the example of §3.1, node 6’s allies at level 2 are {9,10,13,14}\{9,10,13,14\}, one of the two groups that compute the value of nodes 8–15. Nodes exchange signed merge packets with peers and allies. A node accepts the ally value carried by τ\tau distinct allies, discarding any ally seen sending two values, and otherwise records a hole. With MP0MP_0 the CSP, it then computes, for l≥1l \ge1,

MPl=H(MPl−1left∥MPl−1right∥CR∥HC∥DC∥l),MP_l = H\left(MP_{l-1}^{\mathrm{left}} \mathbin\Vert MP_{l-1}^{\mathrm{right}} \mathbin\Vert CR \mathbin\Vert HC \mathbin\Vert DC \mathbin\Vert l\right),

where CRCR is the predecessor root, HCHC the hole count and DCDC the dissent count. A hole at level l≥1l \ge1 adds c2l−1c 2^{l-1} to HCHC, the number of keys it hides, so HC≤nHC \le n. Merges sum HCHC and DCDC over disjoint subtrees.

Merge packets show their work. With a window of ww levels, a node attaches to each merge packet the ww levels of merges beneath the value it vouches for, with their signatures, so that a receiver can recompute that value, counts included, from certified inputs; alternatively, or as well, it attaches its own merge path down to its committee. A group with a Byzantine quorum, τ\tau Byzantine members, therefore cannot invent a value. It can record a hole for a value it received, which HCHC counts but which splits its allies from the rest; omitting inputs without a hole also needs captured groups at the levels whose work it shows. With w=0w = 0 and no path there is no such check, so an instance must use at least one. The same evidence repairs holes. Some of a node’s peers at the next level computed the same value through other ally groups, so a node that recorded a hole can fill it from a peer’s window that carries the missing value, and recompute.

Apart from filling holes from windows, nodes do not reconcile values with peers, so the 2l2^l groups computing a level-ll value agree only if they end with the same holes and dissent. A merge goes wrong when they do not: with c=4c = 4, if two members of one group’s ally group have crashed, that group records a hole while the other groups computing the same value receive it, and unless a window fills the hole, the two sets of nodes finish on different roots. Such holes can cascade (§ 4), and the next cycle reports the split as dissent.

Dissent. Dissent detects a split network (§ 1.2) so that acceptance rolls back instead of continuing on divergent roots. A node that receives a committee packet built on a foreign root CRt−1′CR'_{t-1}, from a sender whose committee under CRt−1′CR'_{t-1} would include it, joins that committee as a dissenter as well as taking part in its own. It does so only if CRt−1′CR'_{t-1} builds on its own CRt−2CR_{t-2}: cycle t−1t-1’s assignment is then common to both roots, so the foreign committee can check the dissenter’s evidence. Dissent must be provable. The dissenter attaches its BuildPath, its record of cycle t−1t-1, from its committee certificate up to CRt−1CR_{t-1}, with the τ\tau peer and ally signatures that each group sends alongside the merge values it creates, the root included; nodes keep these until a cycle is final. A CSP’s dissent field counts the dissenters it includes, and a committee hole contributes zero. A node joins at most one committee per foreign root, so the merged sum DCDC counts dissenting keys without double counting. Holes can still erase dissent: two Byzantine members of a four-node committee can withhold signatures, turning an honest dissenter’s committee into a hole. An accepted root’s holes hide at most Hmax⁡H_{\max} keys, and dissenters land where the foreign root’s assignment places them, so holes can hide at most about one eighth of a split’s dissent.

Acceptance, rebuild and rollback. A node accepts CRt=MPLCR_t = MP_L if it verifies, DC≤Dmax⁡DC \le D_{\max} and HC+DC≤Hmax⁡HC + DC \le H_{\max}: holes and dissenters never count toward a quorum of τ\tau. Both thresholds count keys out of nn. We use Hmax⁡=n/8H_{\max} = n/8 and Dmax⁡=n/16D_{\max} = n/16 as placeholders, not derived thresholds; Hmax⁡H_{\max} tolerates no committee hole when n/c<8n/c < 8. Dmax⁡D_{\max} is a policy knob: a positive value tolerates small splits and leaves the minority to catch up (§5), while Dmax⁡=0D_{\max} = 0 rolls back on any verified split. Since Hmax⁡=n/8H_{\max} = n/8, an accepted root may omit up to one eighth of the committees: the root counts the omission but does not attribute it, and an adversary that places ⌈c/3⌉\lceil c/3\rceil members in a committee chooses whose inputs are omitted. Otherwise, exceeding Hmax⁡H_{\max} triggers a rebuild of cycle tt, a new attempt; since the permutation key is CRt−1CR_{t-1}, a rebuild re-derives the same assignment, so a committee blocked by withholders stays blocked. Excess dissent means many nodes accepted a different CRt−1CR_{t-1}: nodes return to CRt−2CR_{t-2} and rebuild cycle t−1t-1; dissent takes precedence over holes. Finality bounds rollback, so proofs stay usable: once a node accepts cycle tt, it treats CRt−2CR_{t-2} as final and never rolls back past it. Two roots for one cycle that each gain an accepted successor, like conflicting final roots, need more Byzantine nodes than Theorem 5.2 allows; nodes that see either halt, keep the evidence, and restart only as the governance of §8 decides.

Proofs and root trust. For each cycle, a node retains an internal BuildPath containing its committee result and merge records, from which it exports a proof: the committee certificate and one adjacent subtree summary per merge level, with an optional local batch-inclusion claim. A verifier checks that the committee signers form the committee assigned under CRt−1CR_{t-1}, recomputes the cycle root, and compares it with a root it accepts for that cycle. The exported proof carries no peer or ally signatures and does not certify network-wide acceptance of the root. An outside verifier therefore needs an independent rule for choosing trusted roots (§5); compact aggregate root certificates [2] remain future work. With one successful build, a node sends O(c(1+L))O(c(1+L)) messages, whether or not it has anything to commit; proof size and verification work are O(L)O(L) given the roster and CRt−1CR_{t-1}, and retaining BuildPaths or proofs for EE cycles costs O(EL)O(EL) for fixed cc. Windows and paths enlarge merge packets, by about 2w−12^w-1 merges or LL levels of signatures, but add no messages. These bounds exclude retries and dissent.

Security

Model. Within each membership epoch, the roster and public keys are fixed; a signed future epoch can change the roster at a specified cycle. Hashes are collision resistant; signatures are unforgeable and bind cycle, attempt, predecessor root, level, position, phase and value; honest nodes sign at most one value per context. A static adversary controls ff of the nn identities, fixed before a cycle’s permutation is known; adaptive corruption is outside the model. Honest messages arrive within a bound Δ\Delta from which timeouts are set; a message delayed beyond Δ\Delta has the same local effect as a failure.

Lemma 5.1 (Local certificate uniqueness). For a fixed group of cc identities and a fixed signing context, two certificates with τ=⌈2c/3⌉\tau=\lceil2c/3\rceil signers share at least 2τ−c2\tau-c signers. If fewer than c/3c/3 members are Byzantine, two distinct non-hole values cannot both be certified; any two conflicting certificates identify at least 2τ−c2\tau-c double-signers.

Two signer sets of size τ\tau in a group of cc intersect in at least 2τ−c≥⌈c/3⌉2\tau-c\ge\lceil c/3\rceil members, so with fewer than c/3c/3 Byzantine members the intersection contains an honest one, who signs once per context. For c=16c=16, conflicts name six signers. This is the accountability Cambium offers, as in accountable agreement [6]: equivocation is attributable, withholding is not. Nodes keep conflicting certificates as evidence against their signers; what happens to those keys is a membership decision (§8).

Root-relative proof soundness. Given an authentic accepted root and membership configuration, collision resistance and signature checks bind a certified input to its key and cycle root without disclosing other records.

Group sampling. A group can diverge once it holds b=c−τ+1b=c-\tau+1 Byzantine members, which is ⌈c/3⌉\lceil c/3\rceil for cc a power of two: by withholding, they show a value to some honest nodes and a hole to others. Under uniform assignment without replacement, a group of cc does so with probability

pbad=∑k=bc(fk)(n−fc−k)/(nc).(2)p_{\mathrm{bad}}=\sum_{k=b}^{c}\binom{f}{k}\binom{n-f}{c-k}\big/\binom{n}{c}. \tag*{(2)}

(2) assumes an unbiased seed; withholding and forced rebuilds bias it, so the figures below are optimistic, and the static-adversary assumption covers corruption, not assignment. At n=16,384n=16{,}384, f=5,461≈n/3f=5{,}461\approx n/3 and c=16c=16, pbad=0.45p_{\mathrm{bad}}=0.45: group-level divergence is common, and it costs liveness, not safety (Theorem 5.2).

Theorem 5.2 (Finality). Suppose f<n/3f<n/3, honest nodes sign only for the root they accept, and each cycle’s assignment is a uniform permutation. Two conflicting roots for one cycle both become final with probability at most Ge−δn/cG e^{-\delta n/c}. Here GG is the number of assignments the adversary can choose between, and δ=D(78∥qc)\delta=D\left(\frac{7}{8}\|q_c\right), where DD is binary relative entropy and qcq_c is the probability that cc nodes drawn from a two-thirds share of the roster include τ\tau of that share. For c=4c=4 and c=16c=16, δ≈0.19\delta\approx0.19 and 0.250.25.

Proof sketch. After a split at cycle tt, each side’s assignment for t+1t+1 is keyed by its own root, so each side must fill its own committees. Honest nodes sign for one root, and holes and dissenters never count toward a quorum, so the sides’ signer shares, honest members plus all Byzantine ones, sum to at most 1+f/n<4/31+f/n<4/3: all but one side have under two thirds. Such a side accepts t+1t+1 only if at least seven eighths of its n/cn/c committees reach τ\tau signers, while each does so with probability below qcq_c; committee counts under a uniform permutation are negatively associated, so a Chernoff bound gives e−δn/ce^{-\delta n/c}. A rebuild re-derives the same assignment, so retries do not help, and a root becomes final only after it gains accepted successors.

At n=16,384n=16{,}384 and c=16c=16 the bound is G⋅10−111G\cdot10^{-111} per split; at the evaluated n=256n=256 and c=4c=4 it is about G⋅10−5G\cdot10^{-5}. A single deceived node is a split of one: its root never gains a successor. The bound rests on random assignment, as (2) does: adversarial placement could finalise both sides from f≥0.2nf\ge0.2n at c=16c=16. GG measures how far withholding can steer a side’s root before its assignment is fixed; seeding assignment from an external beacon would make G=1G=1. The proof needs only one accepted successor, so finalising CRt−1CR_{t-1} should also be safe; we keep CRt−2CR_{t-2} to give dissent a cycle to arrive, and leave the faster rule to future work.

Catch-up and root trust. The stalled side of a split must rejoin the final chain; techniques for moving from almost-everywhere to everywhere agreement [12] suggest a periodic catch-up step. An outside verifier need not track every root: each root commits to its predecessor, so a verifier that trusts one recent root, for instance one anchored in Bitcoin [24], can check any earlier root on its chain from one constant-size MLM_L-plan per intervening cycle.

Availability. Safety holds for f<n/3f<n/3; liveness does not, and denial of progress is the residual attack. Dissent cannot be raised at will, because each dissenter must present its own certified BuildPath. A key that claims a root no honest node holds needs a false value certified somewhere on its path, and peer signatures push this to the top level, where both the key’s ally group and its own top-level group, which signs the root, must hold a Byzantine quorum. Forcing rollback needs more than Dmax⁡=n/16D_{\max}=n/16 such keys; at n=16,384n=16{,}384 and c=16c=16, about f>0.59nf>0.59n in expectation, against f>0.40nf>0.40n without peer signatures, so below n/3n/3 dissent cannot be forged; windows only raise these bounds. Withholding is stronger: committees with bb Byzantine members become holes at will, and a cycle in which they exceed Hmax⁡H_{\max} stalls for as long as the adversary withholds (§4). Committee holes are each Hmax⁡H_{\max} in expectation at f/n≈0.16f/n\approx0.16 for c=4c=4 and 0.220.22 for c=16c=16, and merge-level holes, each hiding up to 2L−12^{L-1} committees, lower this further. Mixing the attempt number into the seed after a failed rebuild would end the stall, at the cost of more influence over assignment.

Implementation and Evaluation

We implemented a Cambium prototype in Go. We ran one node per AWS ECS Fargate task (2 vCPU, 4 GiB RAM) with c=4c = 4, an EFS-backed proof store and the prototype’s straggler simulation enabled.

In Table 1, each merge level adds 6.9–7.1 messages per node, near the 2c−12c - 1 peer-and-ally contacts, and cycle time grows by 19–41 ms per level. Cycles cannot overlap, because each cycle’s assignment depends on the previous root, so input throughput rises only from 670 to 1,730 inputs per second as nn grows from 8 to 256; batching (§ 0.2) raises commitments per input.

nnmerge levelsmsgs sent/nodecycle timeverify time
8125.512 ms0.62 ms
16232.639 ms0.87 ms
32339.661 ms1.05 ms
64446.788 ms1.20 ms
128553.7107 ms1.37 ms
256660.6148 ms1.49 ms

Table 1. Our AWS measurements, c=4c = 4, simulated stragglers enabled. Messages are sent per node per cycle and averaged over runs, including retries.

Simulated crash faults. We simulated single cycles with random fractions of silent nodes and random offset tables (Table 2); at n=16,384n = 16,384 and c=16c = 16, 8/16 cycles succeed at 5%. The failures are isolated ally-quorum misses (§ 2): at each merge level l≥2l \ge2, a level-(l−1)(l - 1) group, one of n/cn/c, with at least bb of its cc allies crashed records a hole that the other groups computing the same value do not. Level 1 cannot split, since each level-0 stack is a single committee, so with pp given by Eq. (2) for ff crashed nodes, a cycle succeeds with probability about e−(L−1)(n/c)pe^{-(L-1)(n/c)p}. This matches eight of the nine cells of Table 2 to within three runs and predicts 7.7/16 at n=16,384n = 16,384; it overestimates c=64c = 64 at 20%, where holes compound across levels, as an ally hole changes a group’s value and blocks quorum at the next level. Filling holes from windows (§ 2) targets exactly these misses.

The AWS runs used c=4c = 4, which tolerates one Byzantine member per committee. We consider doing further tests with larger nn, differing cc values as well as tests with different crashes, withholding and conflicting root strategies part of future work.

Related Work

Aggregators. A single aggregator receives O(n)O(n) inputs while each client sends O(1)O(1) messages; the aggregator chooses which inputs enter the Merkle root. Keyless signature infrastructure [3] spreads this aggregation over a hierarchy of servers, but a server can drop the inputs below it without accountability, and witness cosigning [22] attests to the root without sharing the choice of inputs. Cambium distributes the load and the choice. Both an aggregator and Cambium need a root-trust rule. Secure in-network aggregation [5] also builds a commitment tree inside the network and lets each contributor check its own inclusion, but relies on a trusted querier.

Timestamping, transparency, consensus. Timestamping uses hash chains or trees [9]; Bitcoin anchoring [24] could supply a wall-clock reference for Cambium’s roots. Certificate Transparency maintains Merkle logs [14]. PBFT and HotStuff totally order requests [4, 25]; interactive consistency and asynchronous common subset deliver vectors or sets [17, 20]. Cambium computes an aggregate instead. Algorand samples committees from prior randomness [8]. Cambium uses its own roots for re-seating and leaves proofs with participants.

Local-first and accountable ledgers. TrustChain keeps a per-agent chain of interactions without global consensus [19], and ConTrib’s per-participant ledger detects fraud through record exchange [7]. Cambium binds such evidence to a shared root. It could anchor Secure Scuttlebutt’s single-writer log heads [11]. Byzantine-tolerant version control [18] and secure CRDTs [10] replicate state; Cambium retains digests. Local digests may rely on double-spend detection [16]; per-cycle inputs give range evidence when senders disclose complete batches.

Operating Shared Infrastructure

In a shared-data cooperative, contributors retain records and proofs that auditors check against accepted roots. This leaves three operational questions.

Membership and recovery. CR0CR_0 fixes the roster, and Sybil resistance is delegated to whoever governs it. That suits institutional ledgers run as commons [1] and closed commons that condition replication on contribution [15], but a roster concentrates authority unless it is accountable: admission and removal rules, authenticated roster versions that keep old proofs verifiable, and a record of who authorised each restart. The prototype stages signed future membership epochs, each authorised by a threshold certificate from the current epoch, without breaking the root chain; it changes nn between powers of two with cc and CR0CR_0 fixed.

Evidence availability. Local retention avoids copying every record everywhere, but applications then need exportable proof bundles and independent retention, and verifiers must distinguish missing evidence from a negative claim.

Participation and exclusion. Someone pays for slow members: either everyone waits for them, or timeouts turn their slow links into holes, so low-bandwidth or intermittently connected members may repeatedly miss cycles, and rebuild burdens may fall on them. An adversary can also target holes at chosen committees (§ 2). Because holes make missing participation visible in the committed structure, a deployment can measure inclusion rate and repeated holes per participant, and respond by tuning timeouts, subsidising operation or delegating hosting. The operational test for a community is whether participants can keep usable evidence, contest exclusion and change operators without losing the ability to verify their records.

Conclusion

Cambium lets participants build a shared commitment root per cycle, with no aggregator or global ordering, while records and proofs stay with their holders. Number of messages per node, total build latency and proof sizes all grow logarithmically with the size of the network. Its final roots agree, with high probability, whenever fewer than a third of the nodes are Byzantine; its liveness needs fewer than that, and untested hole filling is the main engineering gap. Governance, proof availability and inclusion decide whether, and which, community it would best serve.

References

References

  1. [1]L. Barisone and R. Bregy. 2025. Institutional Blockchains as Sustainable Commons: The Case of SwissLedger. In DICG ’25 (ICDCSW).DOI
  2. [2]D. Boneh, M. Drijvers, and G. Neven. 2018. Compact Multi-Signatures for Smaller Blockchains. In ASIACRYPT ’18. 435–464. doi:10.1007/978-3-030-03329-3_15
  3. [3]Ahto Buldas, Andres Kroonmaa, and Risto Laanoja. 2013. Keyless Signatures’ Infrastructure: How to Build Global Distributed Hash-Trees. In Secure IT Systems: 18th Nordic Conference (NordSec) (LNCS, Vol. 8208). Springer, 313–320. doi:10.1007/978-3-642-41488-6_21
  4. [4]M. Castro and B. Liskov. 1999. Practical Byzantine Fault Tolerance. In OSDI ’99. 173–186.
  5. [5]Haowen Chan, Adrian Perrig, and Dawn Song. 2006. Secure Hierarchical In-Network Aggregation in Sensor Networks. In Proceedings of the 13th ACM Conference on Computer and Communications Security (CCS). ACM, 278–287. doi:10.1145/1180405.1180440DOI
  6. [6]P. Civit, S. Gilbert, and V. Gramoli. 2021. Polygraph: Accountable Byzantine Agreement. In ICDCS ’21. doi:10.1109/ICDCS51616.2021.00046DOI
  7. [7]M. de Vos and J. Pouwelse. 2020. ChainTribe: Universal and Decentralized Accounting in Shared-Resource Systems. In DICG ’20.DOI
  8. [8]Y. Gilad, R. Hemo, S. Micali, G. Vlachos, and N. Zeldovich. 2017. Algorand: Scaling Byzantine Agreements for Cryptocurrencies. In SOSP ’17. 51–68. doi:10.1145/3132747.3132757DOI
  9. [9]S. Haber and W. Stornetta. 1991. How to Time-Stamp a Digital Document. Journal of Cryptology 3, 2 (1991), 99–111. doi:10.1007/BF00196791DOI
  10. [10]K. Jannes, B. Lagaisse, and W. Joosen. 2022. Secure Replication for Client-centric Data Stores. In DICG ’22.DOI
  11. [11]A. Kerrmarrec, E. Lavoie, and C. Tschudin. 2020. Gossiping with Append-Only Logs in Secure-Scuttlebutt. In DICG ’20.
  12. [12]Valerie King and Jared Saia. 2009. From Almost Everywhere to Everywhere: Byzantine Agreement with O(n^{3/2}) Bits. In Distributed Computing: 23rd International Symposium (DISC) (LNCS, Vol. 5805). Springer, 464–478. doi:10.1007/978-3-642-04355-0_47DOI
  13. [13]M. Klepmann, A. Wiggins, P. van Hardenberg, and M. McGranaghan. 2019. Local-First Software: You Own Your Data, in spite of the Cloud. In Onward! ’19. 154–178. doi:10.1145/3359591.3359737
  14. [14]B. Laurie, E. Messeri, and R. Stradling. 2021. Certificate Transparency Version 2.0. RFC 9162. doi:10.17487/RFC9162DOI
  15. [15]E. Lavoie. 2023. Designing Peer-to-Peer Systems as Closed Knowledge Commons. In DICG ’23.DOI
  16. [16]E. Lavoie and C. Tschudin. 2022. Local Crypto-Tokens for Local Economics. In DICG ’22.DOI
  17. [17]A. Miller, Y. Xia, K. Croman, E. Shi, and D. Song. 2016. The Honey Badger of BFT Protocols. In CCS ’16. 31–42. doi:10.1145/2976749.2978399DOI
  18. [18]B. Nasrulin and J. Pouwelse. 2021. Decentralized Collaborative Version Control. In DICG ’21.DOI
  19. [19]Pim Otte, Martijn de Vos, and Johan Pouwelse. 2020. TrustChain: A Sybil-resistant scalable blockchain. Future Generation Computer Systems 107 (2020), 770–780. doi:10.1016/j.future.2017.08.048
  20. [20]M. Pease, R. Shostak, and L. Lamport. 1980. Reaching Agreement in the Presence of Faults. J. ACM 27, 2 (1980), 228–234. doi:10.1145/322186.322188DOI
  21. [21]E. Stefanov and E. Shi. 2012. FastPRP: Fast Pseudo-Random Permutations for Small Domains. IACR ePrint Archive (2012), 254. https://eprint.iacr.org/2012/254.pdf
  22. [22]E. Syta, I. Tamas, D. Visher, D. Wolinsky, P. Jovanovic, L. Gasser, N. Gailly, I. Khoffi, and B. Ford. 2016. Keeping Authorities “Honest or Bust” with Decentralized Witness Cosigning. In IEEE S&P ’16. 526–545. doi:10.1109/SP.2016.38DOI
  23. [23]R. Thakur, R. Rabenseifner, and W. Gropp. 2005. Optimization of Collective Communication Operations in MPICH. The International Journal of High Performance Computing Applications 19, 1 (2005), 49–66. doi:10.1177/1094342005051521DOI
  24. [24]P. Todd. 2016. OpenTimestamps: Scalable, Trust-Minimized, Distributed Timestamping with Bitcoin. https://petertodd.org/2016/opentimestamps-announcement
  25. [25]M. Yin, D. Malkhi, M. Reiter, G. Gueta, and I. Abraham. 2019. HotStuff: BFT Consensus with Linearity and Responsiveness. In PODC ’19. 347–356. doi:10.1145/3293611.3331591DOI

Paper details

vlnc:W_cjyk4q6w
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents