TuskForm

The Story Behind TuskForm

Building TuskForm was an exploration into the intersection of user-centric design and truly decentralized infrastructure. My goal was to prove that complex, interactive applications like form builders don't need centralized databases or proprietary clouds to be powerful and user-friendly.

The Inspiration

The web, in its current state, is heavily siloed. When you fill out a form, your data is almost always at the mercy of the service provider’s terms of service and database security. I wanted to build a tool that flips this dynamic. Inspired by the growing ecosystem on the Sui blockchain and the promise of permanent, decentralized storage via Walrus, I set out to create a feedback engine where users truly own their data. The name "TuskForm"—a nod to the SUI mascot—represents a sturdy, immovable approach to digital communication.

How I Built It

TuskForm is a full-stack, decentralized application (dApp) built on React 19 and TypeScript.

Logic & State: The core logic handles form creation and submission using the @mysten/dapp-kit. The state is managed via Zustand, ensuring in-memory performance while syncing with on-chain object states.
Storage Architecture: Rather than storing responses on a traditional server, every submission is serialized as a JSON blob and uploaded to the Walrus network.
Privacy: To handle sensitive data, I integrated Seal for client-side encryption. This ensures that even on a public storage network, data remains private.
Design System: I adopted a Neubrutalist UI aesthetic, focusing on high-contrast, bold, and interactive elements to create a distinct, modern feel that differentiates TuskForm from generic web-form builders.

Challenges Faced

Decentralized State Management: Bridging the gap between the speed of a local UI and the latency of blockchain transactions was tricky. I had to implement a robust optimistic UI update pattern to ensure that the user experience felt snappy, despite the underlying asynchronous network calls.
Encryption Implementation: Ensuring that the Seal protocol correctly encrypted payloads before they touched the network required careful handling of asynchronous cryptographic operations. It was a rigorous exercise in ensuring that zero-knowledge principles were strictly followed.
Cross-Network Failover: Designing the Walrus integration to support multi-publisher fallbacks was essential for reliability. Managing potential network timeouts and ensuring consistent data retrieval from multiple aggregators was a significant architectural hurdle.

What I Learned

This project deepened my understanding of distributed systems. Specifically, I gained a much firmer grasp of:

Data Verifiability: Understanding that every submission's blobId can be verified independently on-chain fundamentally changes how one approaches "trust" in application architecture.
The Power of Move: Writing the smart contracts in the Move language for the SUI ecosystem taught me to prioritize secure, object-oriented state management, where access control is baked into the object itself (e.g., the FormAdminCap).
Mathematical Complexity: While the UI is simple, the underlying verification logic relies on ensuring that the hashing and encryption chains remain unbroken. For instance, verifying a blob storage integrity involves basic hashes where for a large file of size $S$, the probability of a hash collision is negligible given a strong cryptographic hash function $H$, represented as: $$P(\text{collision}) \approx \frac{S^2}{2 \cdot |H|}$$ Maintaining these integrity checks across the decentralized network is what makes the architecture robust.

TuskForm is a step toward a web where tools are owned by their creators, and feedback is preserved, not just stored.