💻 computer science

Federated Sovereign Transport Protocol (FSTP): Verifiable Coordination Without Disclosure

This paper introduces the Federated Sovereign Transport Protocol (FSTP), a Rust-enforced synchronization layer for federated networks that structurally guarantees data confinement, unlinkable identities, and tamper-evident logging to enable verifiable coordination without exposing internal node data.

Original authors: Ramón Soto C. (Department of Accounting, University of Sonora), Liz Soto (Department of Mathematics, University of Sonora)

Published 2026-07-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Ramón Soto C. (Department of Accounting, University of Sonora), Liz Soto (Department of Mathematics, University of Sonora)

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a group of different organizations—like a union, a political party, and a regulated bank—wanting to work together on a big project. They need to coordinate and prove they did their part, but they are legally or ethically forbidden from sharing their private internal documents (like member lists, secret votes, or internal meeting notes) with each other.

Current systems for connecting these groups are like a "glass house." If you send a message, the other side can see the envelope, and if they are sneaky, they might peek inside the letter even if you didn't mean for them to. They rely on a "honor system" where the other server promises not to look.

This paper introduces FSTP (Federated Sovereign Transport Protocol), a new way for these groups to talk that turns the honor system into a structural lock. Here is how it works, using simple analogies:

1. The "Strict Gatekeeper" (The Synchronization Agent)

Think of each organization's computer as a fortress. Inside, they have two rooms:

The Vault: Where all the secret, raw data lives (membership lists, votes).
The Mailroom: Where official, public messages are prepared.

In old systems, a worker could accidentally (or on purpose) grab a document from the Vault and put it in the Mailroom. In FSTP, the "Mailroom" is guarded by a Strict Gatekeeper (called a Synchronization Agent).

This Gatekeeper isn't just a security guard who checks IDs; it's like a factory machine built with a specific mold. The machine is designed so that only specific, pre-approved shapes (like "Event Hashes" or "Verifiable Credentials") can fit into the output slot. If someone tries to force a "Secret Document" (which is the wrong shape) into the machine, the machine physically jams and refuses to run.

The paper explains that this isn't a rule the workers have to remember; it's built into the code itself. If the code tries to send a secret, the computer compiler (the machine that builds the software) stops it before the software even starts. It's impossible to accidentally leak data because the "wrong shape" simply cannot exist in the outgoing message.

2. The "Disposable Mask" (Contextual Identity)

Usually, if you talk to two different groups, they can figure out you are the same person because you use the same name or ID. This is like wearing your face in every room you enter.

FSTP gives every organization a Magic Mask Maker.

When you talk to the Union, you wear a mask that says "Union Member."
When you talk to the Bank, you wear a completely different mask that says "Bank Client."

These masks are mathematically linked to your real identity, but they look completely different to anyone else. Even if the Union and the Bank compare notes, they cannot tell that "Union Member" and "Bank Client" are the same person. This prevents "context collapse," where your private life in one group accidentally gets mixed up with your public life in another.

3. The "Tamper-Proof Ledger with Eraser" (Blocklace)

To prove they did their work, organizations need a shared history log. Usually, these logs are like a chain of paper links. If you want to erase a piece of paper from the middle of the chain, you have to cut the chain, which breaks the whole thing. This makes it impossible to delete private data while keeping the record of that data existed.

FSTP uses a system called a Blocklace, which is more like a tree of hanging tags.

Each tag points to the one before it with a string.
If you need to delete a private document (like a name from a list), you don't cut the string. You just burn the paper inside the tag.
The tag itself remains hanging on the tree, still connected to the rest of the chain.

This is called a "dangling pointer." The record proves that something happened at that time, and the chain remains unbroken and tamper-proof, but the actual private content is gone forever. This allows organizations to satisfy laws that say "delete my data" without breaking the proof that the event happened.

The Result: "Proof Without Exposure"

The paper claims that with these three tools, an outside auditor can walk up to the group and say:
"I can see that the Union voted, the Bank voted, and you both agreed on a result. I can verify your signatures and that the chain hasn't been tampered with."

But the auditor cannot see what the Union voted on, who voted, or what the Bank's internal notes said. The organizations get the benefit of working together and proving their integrity, without ever having to show their private cards to the table.

Why This Matters

The paper notes that this isn't just a theory; it's being built into a real platform called Velyzor for institutions that need high security. The code is open-source, meaning anyone can check the "Strict Gatekeeper" to ensure it really does what it says.

In short: FSTP builds a bridge between private islands where you can shake hands and exchange sealed envelopes, but no one can ever see what's inside the envelopes unless the owner chooses to open them.

Technical Summary: Federated Sovereign Transport Protocol (FSTP)

Problem Statement

Existing federated network protocols (e.g., ActivityPub, Matrix) enable decentralized coordination but rely on operator policy rather than structural constraints to enforce data confinement. In these systems, while message formats and delivery semantics are defined, there is no mechanism preventing a conforming server from emitting internal data (e.g., deliberation records, member votes) into the federation. Consequently, data privacy for institutional participants—such as trade unions, political parties, or regulated firms—depends on trust in the operator's adherence to policy rather than on the protocol itself. Furthermore, existing identity models often rely on globally resolvable identifiers, leading to "context collapse" where distinct social or institutional contexts are flattened, allowing cross-context correlation of user identities. Finally, linear ledger architectures (e.g., blockchains) struggle to reconcile the requirement for immutable audit trails with legal obligations for data erasure (e.g., GDPR), as deleting data breaks the hash chain integrity.

Methodology

The paper introduces the Federated Sovereign Transport Protocol (FSTP), a synchronization boundary and transport layer designed for federated networks with heterogeneous privacy requirements. The methodology relies on three core primitives:

The Synchronization Agent (SA):
- Acts as the exclusive interface between a node's internal data store ( $D_{raw}$ ) and the federation network ( $D_{pub}$ ).
- Compile-Time Confinement: Implemented in Rust, the SA enforces data confinement via the type system. It utilizes a closed enumeration (FstpMessage) representing only authorized output types. Because Rust requires exhaustive pattern matching and the internal data types are not members of this enumeration, the compiler statically rejects any code path attempting to construct a federation message from raw internal data. This transforms data confinement from a runtime check into a compile-time structural guarantee.
- State Machine: The agent transitions through states (idle, validating, composing, transmitting, logging). Any violation of the confinement invariant ( $m \cap D_{raw} = \emptyset$ ) triggers an error path that logs the violation and resets the agent.
Contextual Identity Model:
- Addresses the problem of cross-context correlation. Each entity holds a Global Identity (GII) but derives a unique Contextual Identity (CII) for each federation relationship using a one-way function parameterized by the relationship context.
- Structural Unlinkability: The CII is stable within a specific relationship but cannot be linked to the GII or to CIIs in other relationships without the entity's cooperation. This structurally prevents context collapse.
- Minimum Disclosure: Verifiable credentials are presented under the specific CII, disclosing only the necessary claims for that interaction.
Blocklace Event Substrate:
- Replaces linear append-only logs with a cryptographic directed acyclic graph (DAG) of signed blocks.
- Partial Ordering: Allows concurrent events to exist as parallel branches without forced serialization, preserving the temporal structure of distributed decisions.
- Erasure Compatibility: The Blocklace stores hash pointers to events rather than the events themselves. To satisfy data erasure obligations, the content is deleted from the data store, leaving a "dangling pointer" (the block structure remains intact with its original hash). This preserves the tamper-evidence of the hash chain while removing the sensitive content.
- Efficiency: Synchronization occurs via frontier exchange. The cost is proportional to the symmetric difference ( $\Delta$ ) between node states, independent of the total history size ( $N$ ).

Key Contributions

Structural Data Confinement: The paper demonstrates that data confinement can be enforced by the protocol itself rather than operator policy. By leveraging Rust's type system, FSTP guarantees that raw internal data cannot be emitted, even by a conforming but adversarial peer.
Proof Without Exposure: The protocol enables a federation participant to verify that a process occurred, a credential is authentic, and an outcome is uncorrupted without accessing the internal data that produced these artifacts.
Resolution of the Erasure-Integrity Conflict: The Blocklace "dangling pointer" mechanism provides a structural solution to the incompatibility between immutable audit trails and data erasure rights, a limitation inherent in linear ledger designs.
Contextual Isolation: The protocol structurally prevents the correlation of identities across different federation relationships, addressing a fundamental privacy flaw in existing federated systems.

Results

The paper presents empirical benchmarks for the reference implementation (written in Rust) to validate the efficiency claims of the Blocklace substrate:

Emission Cost: The time to generate synchronization deltas (sync_delta) scales linearly with the symmetric difference ( $\Delta$ ). Throughput remains stable at approximately 2.3 Melem/s regardless of $\Delta$ size.
Independence from History Size: Emission cost is statistically insensitive to the size of the shared history ( $N$ ), even when $N$ increases 50-fold (from 100 to 5,000 blocks).
Reception Cost: After optimizing the frontier cache update mechanism to be incremental, the reception cost (merge_blocks) also scales linearly with $\Delta$ . The initial implementation suffered from $O(N)$ overhead due to full cache reconstruction, which was reduced by 91–98% in the optimized version.
Case Study: A three-institution governance scenario demonstrates that an external auditor can verify the legitimacy of a collective decision by comparing a disclosed deliberation record against a hash in the Blocklace, without requiring access to the deliberation records of other participating institutions.

Significance and Claims

The paper positions FSTP not as a purely academic proposal but as the inter-node transport layer for Velyzor, a governance platform for institutions with demanding confidentiality requirements.

The primary significance claimed is the shift of data sovereignty from a configuration option to a structural consequence of deployment. The protocol does not require nodes to be "decentralized" in a philosophical sense; rather, the act of deploying a conforming node with the synchronization agent structurally guarantees that internal data remains internal.

The authors emphasize that the security argument relies on the open-source nature of the reference implementation (Apache 2.0 license). The guarantee of confinement depends on the ability of any federation peer to inspect, compile, and verify the source code to ensure the FstpMessage enum has not been modified to allow raw data emission.

The paper concludes that FSTP fills a critical gap in federated networking by providing a transport layer that supports heterogeneous privacy requirements, structural identity isolation, and regulatory compliance (specifically regarding data erasure) simultaneously, properties that existing protocols address only partially or not at all. Future work is identified as formal quantification of traffic metadata leakage and empirical benchmarking under realistic network conditions with intermittent connectivity.