Why Atomic Composability Fails for Social Interactions

A social graph update is a state change, not a swap. Following a user, posting content, or updating a profile are asynchronous actions that require persistent, non-atomic state management across multiple blocks.

• Follow tx and post tx cannot be bundled atomically without creating absurd user flows.
• This breaks the "money legos" model where Uniswap -> Aave flows work seamlessly.
• The result is protocols like Farcaster or Lens operating as isolated state silos.

Your on-chain reputation is fragmented across hundreds of protocols. A governance reputation in Compound doesn't translate to underwriting in Aave, and a Lens follower count is meaningless for a Uniswap liquidity position.

• Soulbound Tokens (SBTs) and attestations (EAS) exist but lack a unified graph layer for querying.
• This forces every new social dApp to rebuild its own graph from scratch, a ~$50M+ collective waste in engineering effort.
• The lack of a portable social graph stifles network effects and user lock-in.

Storing social data on-chain (posts, likes, follows) at scale is economically impossible on L1s. A single post on Ethereum Mainnet would cost ~$50+, making platforms like Twitter prohibitively expensive.

• This forces projects onto high-throughput L2s (Base, Farcaster's Frames) or off-chain indexers, reintroducing centralization and fragmentation.
• The data availability problem means social graphs are not verifiably canonical, breaking trust assumptions.
• Solutions like Storage Proofs (EthStorage) and L2 rollups are nascent and not yet socially composable.

Instead of forcing atomic transactions, social protocols must adopt intent-based systems where users declare desired outcomes (e.g., "follow these 10 accounts").

• Solvers (like in CowSwap or UniswapX) can batch and optimize these intents off-chain before settling.
• This separates execution logic from user intent, enabling complex, multi-step social interactions.
• Frameworks like Anoma and SUAVE are pioneering this paradigm for DeFi, which social graphs must adopt.

The fix is standardizing core social primitives—Follow, Post, Like—as verifiable, portable data structures. Think ERC-721 for social actions.

• Lens Protocol's open graph model and Farcaster's on-chain frames are early attempts.
• A shared data layer, potentially using Celestia for data availability and EigenLayer for restaking security, can make these graphs universally accessible.
• This turns social capital into a composable asset that any dApp can permissionlessly read and write to.

Adopt a hybrid architecture where critical social graph edges (follows, subscriptions) are anchored on-chain for portability, while high-volume content (posts, messages) lives on cost-effective decentralized storage (Arweave, IPFS).

• Storage proofs and verifiable credentials bridge the gap, ensuring off-chain data is tamper-proof and attributable.
• This model is used by Farcaster (on-chain IDs, off-chain hubs) and is essential for scaling to 1B+ users.
• It enables atomic composability for value-transfer (tipping, subscriptions) while allowing async social state.

Smart contracts cannot natively verify off-chain social actions. A DAO vote or a game move requires a trusted party to attest to reality, creating a single point of failure and censorship.\n- Introduces a trusted third party into a trustless system.\n- Vulnerable to data manipulation and downtime from oracles like Chainlink or Pyth.\n- Breaks atomicity; the on-chain settlement is decoupled from the off-chain intent.

Defer on-chain verification by having users cryptographically commit to an action first, then reveal it later. Used for voting (e.g., Snapshot for off-chain signaling) and games. State channels (e.g., Connext, Raiden) batch interactions off-chain.\n- Preserves privacy during the commit phase.\n- Reduces gas costs by batching final settlement.\n- Still requires eventual on-chain finality and suffers from data unavailability risks.

All interactive protocols (channels, optimistic systems) assume participants are online to defend their interests. A user who goes offline can be cheated. This is fatal for social coordination where participation is sporadic.\n- Fails for asynchronous, low-stakes interactions (e.g., social media likes).\n- Creates UX friction requiring constant vigilance or watchtower services.\n- Incentivizes centralization into always-online operators.

Users declare a desired outcome (an 'intent') instead of a transaction. A network of solvers (e.g., UniswapX, CowSwap, Across) competes to fulfill it off-chain, submitting only the optimal solution on-chain.\n- Abstracts away complexity from the end-user.\n- Enables cross-domain actions (e.g., swap on Ethereum, bridge to Base, buy NFT).\n- Centralizes power in solver networks, creating MEV and trust dynamics similar to Flashbots.

Complex social interactions (e.g., 'prove you attended the conference') require subjective or costly-to-verify data. Zero-Knowledge proofs can verify computations, but not the initial data's truthfulness. Worldcoin's orb demonstrates the physical centralization needed for 'proof of personhood'.\n- ZK proofs shift, but do not eliminate, trust to data providers.\n- Cost prohibitive for high-frequency micro-interactions.\n- Inherent trade-off between decentralization and verifiability of real-world events.

Projects like Dark Forest and Lattice's MUD embrace fully on-chain state and logic, making social interactions within the game verifiable and atomic. The 'world' is the blockchain.\n- Achieves true atomic composability for in-system actions.\n- Creates a hard boundary; anything outside the chain (Discord, Twitter) breaks the model.\n- Extremely expensive for storage and computation, limiting scale and complexity.

Atomic transactions require a globally consistent, final state. Human consensus is slow, probabilistic, and subjective, creating a ~1-7 day latency mismatch with blockchain finality. This kills UX for anything requiring off-chain verification.

• Problem: You cannot atomically swap a token for a signed legal document or a verified KYC check.
• Solution: Architect for eventual consistency using oracles (Chainlink) and dispute resolution layers (like Optimism's Cannon).

Atomic composability exposes all transaction logic and state changes on-chain. For social interactions (voting, reputation, salaries), this is a non-starter due to sybil attacks and privacy violations.

• Problem: On-chain voting with atomic execution reveals individual choices, enabling coercion.
• Solution: Use zero-knowledge proofs (zkSNARKs via Aztec, zkSync) or secure multi-party computation to compute outcomes without exposing inputs.

Asking users to specify how (complex, composable transactions) fails for social apps. They should specify what (intent). UniswapX and CowSwap pioneered this for swaps; social needs a generalized solver network.

• Problem: Users cannot be expected to compose DAO votes, payment streams, and attestations into one atomic bundle.
• Solution: Build solver networks that fulfill user intents off-chain and settle guarantees on-chain, similar to Across or SUAVE.

Social data (identity, reputation, credentials) lives off-chain. Instead of fighting this, embrace verifiable off-chain computation as a core primitive. EigenLayer AVSs and HyperOracle are making this programmable.

• Problem: Trying to force social state on-chain is expensive and slow (> $1M/year for active datasets).
• Solution: Use restaking to secure off-chain verifiable compute layers that post succinct proofs of social state transitions.

Atomic composability works within a single state environment (e.g., one EVM chain). Social graphs and communities are inherently multi-chain and multi-platform. LayerZero and CCIP solve messaging, but social state requires portable identities.

• Problem: A user's reputation on Farcaster is useless for a grant vote on Optimism.
• Solution: Build with portable attestation frameworks (EAS, Verax) and universal resolver standards that work across any execution layer.

In DeFi, composability is cooperative (one contract's output is another's input). In social systems, actors have opposing interests (e.g., disputing a moderation decision). Atomic execution cannot handle this without a trusted judge.

• Problem: An atomic "appeal and slash" transaction requires one party to willingly sign their own penalty.
• Solution: Design for non-atomic, dispute-driven resolution using escrows and adjudication protocols (Kleros, UMA).