The main examples include ethers -> viem (evm) , web.js -> kit (solana).

The Unlock 🔑

Separate what you have (data/client) from what you do (actions/functions). This flip enables tree-shaking that OOP prevents. For web3 libraries, that's an 80%+ bundle size reduction.

• OOP: client.getBalance(address) - the client "has" methods

• Action-based: getBalance(client, { address }) - functions take data

This inversion unlocks:

• Tree-shaking (import only what you use)

• Composition (wrap functions, not extend classes)

• Adapters (any object with right shape works)

// Traditional OOP
client.sendTransaction({ to, value })

// Action-based
sendTransaction(client, { to, value })

Why It Matters

Bundle size kills DApps.

// Ethers (OOP)
import { Provider } from 'ethers'
// ~116KB - ALL methods bundled

// Viem (Action-based)
import { getBalance, sendTransaction } from 'viem/actions'
// ~15KB - only what you use

80%+ reduction from architecture alone.

Real impact:

• Faster load times

• Better developer experience

• Better mobile UX

Pattern Recognition

Same evolution everywhere:

Inspired by React too: Hooks are action-based (useState(value) not this.state)

When to Use it

Good fit:

• Building libraries for others

• Bundle size critical (DApps)

• Need extensibility (protocols)

Bad fit:

• Internal tools (bundle size doesn't matter)

• Team strongly prefers OOP

• Need method chaining

Origins

It's not a new concept, it's inspired by:

• Functional programming (Haskell, Clojure)

• Systems languages (Go, Rust)

• React Hooks