Wrapped FLOW

Flow’s native token exists in two worlds. FLOW powers the native blockchain, staking, fees, storage. Wrapped FLOW (wFLOW) powers the EVM ecosystem: DeFi protocols, cross-chain liquidity, composability with Ethereum-native applications.

The growth of wFLOW supply isn’t just a technical detail. It’s a signal. When FLOW gets wrapped, it means developers are building on Flow EVM. It means liquidity is flowing into DeFi protocols. It means the ecosystem is expanding beyond native Cadence applications into the broader EVM landscape.

wFLOW has become essential infrastructure for Flow’s DeFi expansion. Here’s why it exists, how it works, and what it unlocks.

What Wrapped FLOW Actually Is

Wrapped FLOW is an ERC-20 token representation of native FLOW. The wrapping process is straightforward: lock native FLOW in a smart contract, mint an equivalent amount of wFLOW. The wrapped token maintains 1:1 parity with FLOW. Unwrapping reverses the process, burn wFLOW, unlock FLOW.

This pattern isn’t unique to Flow. Wrapped ETH (WETH) serves the same purpose on Ethereum. Wrapped BTC (WBTC) brings Bitcoin liquidity to Ethereum DeFi. Wrapped tokens solve a fundamental problem: native blockchain tokens don’t always conform to the token standards required by smart contracts and DeFi protocols.

FLOW, as a native token on Flow blockchain, works seamlessly with Cadence smart contracts. But EVM smart contracts on Flow, the ones deployed post-Crescendo, expect ERC-20 tokens. They can’t directly interact with native FLOW. That’s where wFLOW comes in.

When developers build DeFi protocols on Flow EVM, they need a version of FLOW that behaves like any other ERC-20 token. Liquidity pools, lending markets, yield farms, all require standardized token interfaces. wFLOW provides that standard.

Why Flow Needs Two Versions of FLOW

Flow’s dual execution environment, Cadence and EVM, creates the need for wrapped tokens.

Native FLOW works with Cadence. Flow’s resource-oriented programming model treats assets as first-class resources. FLOW integrates directly with Cadence smart contracts, account storage, and Flow’s native architecture. No wrapping required.

wFLOW works with EVM. Crescendo brought full EVM equivalence to Flow. Solidity contracts deploy unmodified. Ethereum tooling works out of the box. But those contracts expect ERC-20 tokens. They’re built for Ethereum’s token standards, not Flow’s native resource model.

Wrapping bridges that gap. It lets EVM developers use FLOW in their protocols without learning Cadence. It lets Ethereum-native DeFi patterns, Uniswap-style AMMs, Aave-style lending, Curve-style stableswaps, deploy on Flow with FLOW as the base asset.

The alternative would be forcing every EVM protocol to implement custom logic for handling native FLOW. That’s friction developers won’t tolerate. wFLOW removes the friction.

wFLOW’s Role in Flow’s DeFi Growth

Flow’s DeFi ecosystem exploded post-Crescendo. TVL went from $17 million in early 2024 to over $100 million by mid-2025. wFLOW enabled much of that growth.

KittyPunch’s entire DeFi suite runs on wFLOW. PunchSwap, StableKitty, AggroKitty, all require wFLOW as the base trading pair. The “3kitty” stableswap pool (wFLOW, WETH, USDF) routes most stable-asset trades on Flow. That pool wouldn’t exist without wFLOW. KittyPunch climbed from $2.8 million TVL to over $33 million in Q1 2025. wFLOW liquidity made that possible.

IncrementFi supports both FLOW and wFLOW. As Flow’s original DeFi protocol, Increment bridges native and EVM ecosystems. Users can provide liquidity in either version. That flexibility matters. Native Flow users don’t need to wrap. EVM users get the token standard they expect.

MORE Markets lends against wFLOW. The lending protocol launched with wFLOW as a core collateral asset. Borrowers deposit wFLOW, borrow stablecoins or other assets. Lenders supply capital, earn yield. Standard DeFi mechanics, enabled by wrapped tokens.

Cross-chain protocols use wFLOW. When FLOW bridges to other chains through LayerZero, Axelar, or deBridge, it often moves as wFLOW. EVM-compatible bridges expect ERC-20 tokens. wFLOW fits that model. Native FLOW doesn’t.

wFLOW isn’t just a convenience. It’s foundational infrastructure for Flow’s EVM DeFi ecosystem.

The Liquidity Question

Wrapping creates liquidity fragmentation. FLOW exists in two forms: native and wrapped. That splits liquidity between Cadence and EVM ecosystems.

Is that a problem?

Sometimes. In theory, fragmented liquidity reduces efficiency. Traders might get worse prices because liquidity is split across multiple pools. Protocols might struggle to bootstrap because users hold different versions of the same token.

In practice, Flow’s DeFi ecosystem is still small enough that fragmentation hasn’t crippled growth. TVL increased 500%+ year-over-year despite dual-token dynamics. Protocols adapted. KittyPunch standardized on wFLOW. IncrementFi supports both. Bridges convert automatically.

The long-term question is whether Flow’s DeFi ecosystem consolidates around one version or maintains both indefinitely. Ethereum mostly standardized on WETH for DeFi. Native ETH still exists for staking and gas, but DeFi protocols overwhelmingly use WETH.

Flow might follow that pattern. As EVM DeFi grows, wFLOW could become the de facto standard for financial applications. Native FLOW remains for staking, fees, and Cadence applications. Both coexist, serving different purposes.

Or Flow could build bridges that abstract the difference. Protocols that automatically convert between native FLOW and wFLOW based on context. Users never think about which version they’re holding. The chain handles it invisibly.

That’s speculation. For now, both versions matter, and wFLOW enables growth native FLOW can’t.

Wrapping Mechanics and Security

wFLOW’s security depends on the wrapping contract. If the contract is compromised, all wrapped tokens are at risk.

Flow’s wFLOW implementation uses audited smart contracts. The process is straightforward: deposit native FLOW into a vault, receive equivalent wFLOW. The contract holds the native tokens in escrow. When users unwrap, the contract burns wFLOW and releases native FLOW.

This is custodial in the sense that wrapped tokens depend on the vault contract’s security. But it’s non-custodial in the sense that no centralized entity controls the vault. The contract enforces rules. Redemption is automatic and permissionless.

Compare that to WBTC on Ethereum. WBTC is custodial. BitGo holds the underlying Bitcoin. Users trust BitGo to maintain reserves and honor redemptions. That’s centralization risk.

wFLOW eliminates that risk. The wrapping contract is on-chain, auditable, and enforceable. No intermediary can freeze funds or deny redemptions. The trust model is smart contract security, not institutional trust.

That matters for DeFi. Protocols building on Flow want guarantees that wFLOW maintains 1:1 parity with FLOW. Smart contract enforcement provides that guarantee. Custodial wrapping doesn’t.

Cross-Chain wFLOW

wFLOW doesn’t just exist on Flow. It bridges to other chains.

LayerZero’s OFT (Omnichain Fungible Token) standard lets FLOW move across 70+ blockchains. When FLOW bridges to Ethereum, Arbitrum, Base, or other EVM chains, it often becomes wFLOW on the destination chain.

That unlocks composability. FLOW holders on Ethereum can use wFLOW in Ethereum DeFi protocols. Uniswap liquidity pools, Aave lending markets, Curve stableswaps. All accessible with Flow’s native token.

The benefit is liquidity access. Flow’s DeFi ecosystem is smaller than Ethereum’s. Bridging wFLOW to Ethereum lets FLOW tap into billions in existing liquidity. Traders get better prices. Protocols get deeper markets.

The risk is fragmentation across chains. wFLOW on Flow, wFLOW on Ethereum, wFLOW on Arbitrum. Each chain has separate liquidity. Bridging between them isn’t instant or free. That creates arbitrage opportunities but also friction.

Flow’s bridge integrations, LayerZero, Stargate, Axelar, deBridge, minimize that friction. Transfers happen in minutes, not hours. Fees stay reasonable. The infrastructure works.

But cross-chain wFLOW is still early. Most FLOW stays on Flow. As more protocols integrate LayerZero and cross-chain functionality matures, wFLOW’s cross-chain presence will grow.

What wFLOW Growth Signals

When wFLOW supply increases, it means native FLOW is being locked and used in DeFi protocols. That’s a positive signal.

It means developers are building EVM applications on Flow. It means users are providing liquidity, taking loans, farming yields. It means Flow’s DeFi ecosystem is functional and growing.

wFLOW supply is a more direct indicator of DeFi activity than TVL alone. TVL includes stablecoins, bridged assets, and other tokens. wFLOW measures how much native FLOW is actively deployed in financial applications.

High wFLOW supply suggests confidence. Users are willing to lock FLOW into smart contracts, accepting smart contract risk in exchange for yields or utility. That’s different from holding FLOW in a wallet for speculation.

Low wFLOW supply might indicate caution, users prefer holding native FLOW, staking it, or simply not engaging with DeFi. Or it might indicate lack of DeFi options. If protocols don’t exist, users can’t wrap and deploy FLOW even if they want to.

Flow’s wFLOW supply has grown alongside its DeFi ecosystem. As KittyPunch, MORE Markets, and other protocols launched and gained traction, wFLOW supply increased. That correlation isn’t coincidence. It’s cause and effect.

The Trade-Off

Wrapped tokens solve real problems. They enable cross-ecosystem composability. They let native blockchain tokens work with standard token interfaces.

But they also create complexity. Users need to understand when to wrap and unwrap. Developers need to decide which version to support. Liquidity fragments between native and wrapped versions.

Flow accepted that trade-off when it launched Crescendo and full EVM equivalence. Supporting both Cadence and EVM execution environments means supporting both native FLOW and wFLOW.

The alternative would be forcing EVM developers to use native FLOW directly. That’s technically possible but practically unrealistic. Ethereum developers expect ERC-20 tokens. Changing that expectation would limit Flow’s appeal to Solidity developers, the exact audience Crescendo aimed to attract.

So Flow runs both. Native FLOW for Cadence. wFLOW for EVM. Users bridge between them as needed. Protocols choose which version fits their architecture.

It’s not elegant. But it works.

Final Thought

Wrapped FLOW isn’t flashy. It’s infrastructure. The kind of technical detail most users never think about but can’t function without.

wFLOW enables Flow’s DeFi ecosystem to tap into Ethereum’s development patterns, tooling, and liquidity. It lets Solidity developers build on Flow without learning Cadence. It lets FLOW move across chains through standard bridge protocols.

As Flow’s DeFi ecosystem grows, wFLOW’s role expands. More protocols, more liquidity, more reasons to wrap. That’s not speculation. It’s already happening. KittyPunch, MORE Markets, IncrementFi, cross-chain bridges, all depend on wFLOW.

Flow’s dual-token model is a consequence of its dual execution environment. Cadence and EVM coexist. So do FLOW and wFLOW. That’s not a bug. It’s the design.

wFLOW is the bridge between Flow’s past and its future. Between resource-oriented programming and EVM compatibility. Between native architecture and cross-chain composability.

It’s not the most exciting part of Flow’s ecosystem. But it’s one of the most important.