Deskryptow — building a web3 framework when I didn't believe in web3

I have complicated feelings about web3. But the engineering problems are genuinely interesting — reactive state, offline queues, cross-system consistency. So I built Deskryptow, a TypeScript framework that abstracts blockchain interactions behind a clean API.

The irony is not lost on me.

what it does

Deskryptow provides a reactive state management layer that syncs with a blockchain. Think of it as Redux + a remote database where the database is a distributed ledger.

const state = useContractState(myContract, "balanceOf", [userAddress])
// state auto-updates when the chain state changes

the architecture

Application (React/Vue/Svelte)
    ↓
Deskryptow Core (reactive state, transaction management)
    ↓
Provider Layer (Web3, custom RPC, local dev node)
    ↓
Blockchain / Local Dev Environment

The core insight is that blockchain interactions are just async side effects with retry logic. Wrap them in a reactive state container and the application code doesn't need to think about the blockchain at all.

why this is useful outside of web3

The same patterns apply to any system with:

1. Optimistic updates (assume success, rollback on failure)
2. Eventual consistency (changes propagate asynchronously)
3. Unreliable network connections

The transaction queue with retry + exponential backoff? That's useful for any API client. The reactive state that invalidates when on-chain state changes? That's a cache invalidation pattern applicable everywhere.

I extracted these patterns as a standalone library (@deskryptow/reactive-state) that has zero blockchain dependencies. You can use it with any API.

what I learned

The web3 tooling ecosystem is immature but improving. Ethers.js is solid. Viem is better. But the dev experience is nowhere near what you get with a Postgres-backed REST API. Local node simulation helps but doesn't replace real testnet testing.

TypeScript makes everything better. Even in the web3 space where most tools rush to ship, TypeScript catches enough edge cases to be worth the overhead. We have strict mode, noUncheckedIndexedAccess, and exactOptionalPropertyTypes enabled.

Don't abstract away the chain completely. Users need to know when a transaction is pending, confirmed, or failed. Hiding the blockchain behind a magic reactive layer leads to confusion ("why is my balance not updating?"). The framework provides reactive state and a transaction status observable.

The framework is open source — github.com/AKhilRaghav0/Deskryptow. It works even if you're skeptical about web3. The reactive patterns are the real value.