⬅ Back to Wrapped Tokens

WETH — The ERC-20 Suit for Ether

🧐 What it is:

WETH is ETH wrapped into an ERC–20 token. Because native ETH isn’t ERC–20 (no approve/transferFrom), many DeFi protocols can’t handle it directly. WETH fixes that: convert 1:1 ETH → WETH to “speak ERC–20” wherever it’s required — and unwrap 1:1 back to ETH when you’re done.

🔑 Key facts:

  • 🔢 Decimals: 18

  • 🧾 Canonical contract (Ethereum L1): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2 — (always verify the full checksummed address before interacting)

  • 🔗 Refs: Etherscan — WETH

  • 💰 Solvency: Fully collateralized 1:1 by ETH held in the contract. Verifiable on–chain.

🛠️ How it works: beginner-friendly
  • 🔁 Wrap: Call the deposit function and send ETH to the WETH contract. The contract mints the same amount of WETH and credits it to your address at a 1:1 rate.
    • Mint: Creating new tokens in the contract’s internal ledger.
    • Units: ETH uses 18 decimals on–chain. Internally, amounts are in wei; 1 ETH = 1e18 wei.
    • Also valid: Many WETH contracts auto–wrap if you send ETH directly to the contract address; the contract internally executes deposit and mints WETH to your address.
  • 🔄 Unwrap: Call the withdraw function with the amount you want to burn. The contract burns that amount of WETH and sends the same amount of ETH 1:1 to the calling address (the caller).
    • Burn: Permanently removing tokens from circulation.

      💫 WAFFTip: If you want the ETH to arrive at a different wallet, first transfer the WETH to that wallet and have that wallet execute withdraw.

  • ⚙️ERC–20 behavior: Once you hold WETH, it behaves like any ERC–20. You can:
    • transfer to send tokens.
    • approve to grant a third party a spending limit (allowance) — revoke.cash
    • transferFrom to let that third party move your tokens within the approved limit — ERC-20 Approve and TransferFrom
    • balanceOf to check an address’s balance — ERC-20 balanceOf
    • totalSupply to see the total number of tokens in existence.
  • ⛽ Fees (gas): The WETH contract does not charge a protocol fee. You only pay gas, which is the network fee in ETH. Some applications may add their own fee and should display it before you confirm.
    • ⚠️ Important: Keep some ETH for gas; you cannot pay gas with WETH.
  • 🧪 Quick example:

    ✺ Wrap 1 ETH → deposit transaction → you receive 1 WETH. (You send 1 ETH to the WETH contract via the deposit function; the contract mints 1 WETH to your wallet, and you pay a small network (gas) fee in ETH.)

    ✺ Unwrap 0.5 WETH → withdraw transaction with 0.5 ether (i.e., 500000000000000000 wei) → you receive 0.5 ETH back at the calling address.
    The amount is passed in wei because the blockchain represents values as integers (no decimals).

     

🔄 Remember: the operation returns 0.5 ETH, but the transaction also consumes gas (paid in ETH).

💡 Why it matters:
  • 🔐 Approvals: Giving permission for a contract to move your token.
    Imagine handing a cashier a slip that authorizes spending up to X$ from your account.

    👉 approve is that: you authorize a contract (e.g., a DEX) to move your s without having to sign every transfer. This enables automated “swap”–style flows without prompting each time.

  • 🤝 transferFrom: The movement that uses that permission.
    If you already granted permission, the contract calls transferFrom  and moves your WETH for you. It’s the practical execution of the permission: the contract takes the token from the owner and puts it where it belongs, all in a single logical operation.

    🔗 Do it on–chain (transferFrom): Etherscan — WETH (Write Contract)

  • 🧩 ERC–20 standardization: Everyone speaks the same language.
    Native ETH does not follow ERC–20, which forces developers to write special–case code. WETH is ETH in ERC–20 form: same standard, same functions (approve, transfer, balanceOf, etc.). That simplifies code and speeds up integrations: if your contract understands ERC–20, it can already handle WETH with no extra tricks.

    🔗 vReference: ERC-20 Standard (EIP-20)

  • 🏧 AMMs/DEXs (Automated Market Makers / Decentralized Exchanges): Token vending machines.
    These automated systems need ERC–20 tokens to quote prices and execute swaps. With WETH you can put ETH into those pools like any other token: provide liquidity, make swaps, earn fees. WETH makes ETH “compatible” with the machines.
  • 🎨 NFT marketplaces and auctions: Uniform payments and rules.
    Many NFT markets expect ERC–20 tokens for transfers, deposits, and auctions. If you want to bid or receive payments in “ETH,” converting it to WETH makes it straightforward: same call, same logic, no workarounds.

    🔗 Guide: OpenSea Help — What is WETH

  • 🏦 Vaults/strategies/compound actions: Multiple moves in a single play.
    Complex strategies (e.g., you deposit, stake, and reinvest) need to move tokens across several contracts within one operation. WETH enables atomic operations (everything in a single tx): you deposit WETH into a vault and the contract can route it without asking you for multiple signatures.

    🔗 Explore vaults: Yearn Docs — Vaults

  • ☢️ Atomic operations (all–or–nothing): Everything or nothing, without getting stuck halfway.
    If a workflow bundles several steps (swap → add liquidity → stake), doing it in a single transaction prevents you from getting stuck mid–process. WETH lets contracts execute those steps internally using transferFrom, etc., and if anything fails, the tx reverts—you don’t get stuck.

    🔗 Background: ethereum.org — Transactions (atomicity)

  • 🧭 UX / Auto–wrap: The app does it for you.
    Many dApps detect when you need WETH and automatically call deposit behind the scenes (or show “Convert ETH → WETH” as a step). For the user it feels like magic: you sign and the app handles the rest, because internally it needs the asset to be ERC–20.

    🔗 Example interface: Uniswap Web App

✩ WAFFT summary: WETH matters because it turns ETH into a token that all DeFi contracts and UIs understand. That enables permissions (approve), automatic transfers (transferFrom), clean integrations with AMMs/marketplaces/vaults, and compound operations in a single tx—in short, it makes ETH as flexible and composable as any ERC–20 token. ✨

💼 Use it for:
  • 🧪 Provide liquidity and trade on AMMs/DEXs: WETH pairs with almost everything (e.g., WETH/USDC). If you provide liquidity, you deposit WETH alongside another token and receive LP tokens — they represent your share of the pool and the fees it earns; swaps with WETH are straightforward and don’t require odd adapters.

✺ Short example: you want to add liquidity on Uniswap V3 — deposit WETH + USDC into the corresponding pool.

  • 🖼️ Bid and list on marketplaces/auctions that accept ERC–20: Many markets allow payments in WETH for bids or purchases (convenient because it follows the ERC–20 standard).

    ✺ Short example: in NFT auctions that accept tokens, paying in WETH enables instant transfers using transferFrom.

  • 🧰 Vaults, yield & on–chain automations: Tools that manage strategies (deposit, reinvest, rebalance) usually require ERC–20. With WETH you can deposit your “tokenized” ETH and let the contract handle the automation.

    ✺ Short example: a vault receives WETH, allocates positions, and rebalances without you having to sign each step.

  • 📒 Treasury / on–chain accounting: For projects or DAOs, it’s easier to track inflows/outflows when ETH is in ERC–20 form (balanceOf, events). WETH simplifies on-chain reporting and reconciliation.

    ✺ Short example: a project treasury keeps its reserve in WETH to make ERC–20 payments and move funds programmatically.

  • 🔁 Bridges and cross–contract flows (composability): When multiple actions must be chained within a single transaction (swap → add liquidity → stake), WETH lets contracts pass tokens between themselves without special conversions.

    ✺ Short example: a contract calls transferFrom to pull WETH, performs a swap, and deposits the result — all in a single transaction.

🛡️ Allowance hygiene & security:

🔍 Approval = permission for a contract (e.g., a DEX or a vault) to move your tokens on your behalf up to a limit you define.

  • 🧼 Review your approvals periodically: Over time you grant permissions to many dApps and then forget them. Open the “Token Approvals” section in the explorer or use a revocation tool to see which contract can spend how much of your WETH and revoke what you no longer use.

    🔗 Useful links: Etherscan — Token Approvals / Revoke.cash — Approval Revoker

  • 🔒 Avoid unlimited approvals (unlimited): An “unlimited” is like giving a blank check. Convenient, yes (it won’t ask every time), but if that dApp becomes insecure, the risk is greater. It’s better to approve only what you will use; if you already granted an unlimited, revoke it when you’re done and, if needed, approve a specific amount again.

  • 🧠 How to read an approval in the UI: It usually says “Allow this contract to spend up to X WETH.”

    🔸 Spender: the contract that will be able to spend (e.g., the DEX router).

    🔸 Amount: the spending cap. If you see “unlimited” or an enormous number, that’s the no–limit mode.

How to read an approval in the UI — WETH
  • 🖊️ permit (EIP–2612) vs traditional approve:

    🔸 Traditional approve: you send an on–chain transaction to grant permission (you pay gas).

    🔸 permit: you grant permission with an off–chain signature (no gas for that approval).

    🔸WETH9: (canonical) does not have permit; some alternative wrappers (e.g., “WETH10”) do implement it, but don’t assume it: if the token doesn’t support permit, the dApp will ask for a normal approve.

    🔗 References: EIP-2612 — Permit / WETH10 — GitHub

  • 📨 Permit2 is not part of WETH9: Some dApps use Permit2 (a signature–based permission system) to manage approvals more conveniently. That belongs to the dApp, not a native WETH9 feature. Before signing, read carefully: which token? how much? who (spender) will be able to spend? If something doesn’t add up, cancel.

    🔗 Reference: Uniswap Docs — Permit2

  • 🧩 Scope of approvals (what they cover): An approval is per token and per contract. If you revoke the approval of WETH → Spender A, it does not affect WETH → Spender B or other tokens. This lets you clean permissions selectively without breaking everything.
  • 🧿 Phishing and fake “WETH”: Always verify that the token is the canonical one:

    🔸 Exact checksummed address (don’t trust the name alone).

    🔸 Decimals = 18 for WETH.

    🔸 Your explorer marks the contract as verified and correctly referenced. If the name says “WETH” but the address doesn’t match your network’s official one, it’s not the right token.

    🔗 Quick check: Etherscan — WETH token page

  • 🧰 Mini–procedure to revoke (step by step):

    🔸 Open “Token Approvals” / a revocation tool.

    🔸 Connect your wallet in read–only mode.

    🔸 Filter by WETH → identify the spender you no longer use.

    🔸 Click Revoke → confirm (you’ll pay a bit of gas).

    🔸 Done: that contract can no longer move your WETH.

  • 🧪 Why this matters with WETH: WETH is used in AMMs/DEXs, vaults, and automations thanks to approve/transferFrom. That power comes with responsibility: you control who can move your WETH and up to how much. Approval hygiene lets you enjoy DeFi composability without leaving doors open.

💡WAFFTip : monthly routine — review approvals → limit by amount → revoke the old stuff.

At WAFFT lab, this is the pro investor’s “hand–washing.” 🧼👐

⚠️ Watch out for… 
  • 🧭 Not a bridge or a peg:

    🔸 Bridge = moving value across chains.

    🔸 Peg = fixed parity backed by reserves.

    WETH doesn’t do that: it only wraps your ETH on the same network in ERC–20 form and unwraps 1:1 on that same network.

    ✵ Example: WETH on Arbitrum → ETH on Arbitrum (not L1). For L2 ↔ L1 you need a separate bridge.

    🔗 Background: ethereum.org — Bridges / ethereum.org — Layer 2

  • 💤 Not yield-bearing: Holding WETH in your wallet doesn’t earn interest. The yield comes from where you use it (pools, lending, strategies). WETH is the key; the yield is behind the door. 🔑

📝 Final note:

WETH is ETH’s universal adapter in DeFi. Master it, and you’ll move your Ether like a pro—fast, clean, and no drama–free. It’s the bridge between raw ETH and the ERC–20 world. And if you ever need to clarify a concept, search it in WAFFT’s own «Google of money«. 🔎🚀

🎁[WAFFT Explains]

🔸 Smart contract: A program that runs on Ethereum exactly as written; it can hold funds and enforce rules automatically.

🔸 ERC-20: A common set of rules for tokens on Ethereum; defines standard functions such as transfer, approve, balanceOf, and others.

🔸 Gas: The network fee paid in ETH to execute a transaction or call a contract.

🔸 Wei: The smallest unit of ETH. 1 ETH = 1,000,000,000,000,000,000 wei (1e18). Contracts operate internally in wei.

🔸 deposit: WETH function for wrapping: you send ETH and receive WETH 1:1.

🔸 withdraw: WETH function for unwrapping: you burn WETH and receive ETH 1:1 at the address that executes the call.

🔸 Payable: Indicates that a function can receive ETH along with the call.

🔸 Caller: The address that initiates the transaction; when unwrapping, the ETH is sent to this address.

🔸 Mint / Burn: Create or remove tokens within the contract’s accounting.

🔸 Allowance: A spending limit you grant to another address (for example, a dApp) so it can move your tokens on your behalf.

🔸 Approve: Action to set or update that spending limit.

🔸 TransferFrom: Movement of tokens by the authorized third party, always within the allowance.

🔸 Total supply: The total number of tokens that exist for that contract.

👉 Up next: explore wstETH — Wrapped Staked Ether (Non-Rebasing) and learn how Ethereum staking meets ERC–20 perfection: fixed balances, yield through exchange rate, and seamless composability. 🧩⚡