Woofi Yield

Woofi Yield Skill — Aave, Spark & Morpho Deposit / Withdraw

Aave

Aave V3

1. Overview

Aave V3 is the largest decentralized lending protocol. Users supply an underlying asset (e.g. USDC) and receive an aToken in return. aTokens are minted 1:1 with the supplied asset; their balance grows automatically over time to reflect accrued interest.

Key points:

• V3 uses supply() (renamed from V2's deposit())
• aToken balances rebase — no need to claim rewards separately
• supplyWithPermit() is available for gasless approvals on EIP-2612 tokens

Supported chains:

2. Pool & Token Registry

Pool Addresses

USDC Reserves

USDT Reserves

Sonic, Scroll, and Gnosis do not have USDT reserves on Aave V3.

WETH Reserves

WBTC / BTC Reserves

Sonic, Scroll, and Gnosis do not have WBTC reserves on Aave V3.

3. Pool Contract Interface

Write Functions

// Supply `amount` of `asset` to the pool on behalf of `onBehalfOf`
// referralCode is deprecated — pass 0
function supply(
    address asset,
    uint256 amount,
    address onBehalfOf,
    uint16 referralCode
) external;

// Withdraw `amount` of `asset` from the pool, sending to `to`
// Pass type(uint256).max to withdraw the entire balance
function withdraw(
    address asset,
    uint256 amount,
    address to
) external returns (uint256);

// Supply with EIP-2612 permit (gasless approval)
function supplyWithPermit(
    address asset,
    uint256 amount,
    address onBehalfOf,
    uint16 referralCode,
    uint256 deadline,
    uint8 permitV,
    bytes32 permitR,
    bytes32 permitS
) external;

ERC-20 Approve (prerequisite for supply)

// Approve the Pool to spend underlying tokens on behalf of msg.sender
IERC20(underlying).approve(poolAddress, amount);

4. Operation Flows

Deposit Flow

1. Resolve the Pool address and underlying token address for the target chain/asset.

2. Check user balance:
   balance_raw = IERC20(underlying).balanceOf(user)

3. Approve Pool to spend underlying:
   IERC20(underlying).approve(pool_address, amount_raw)

4. Execute supply:
   pool.supply(underlying, amount_raw, user, 0)
   → User receives aTokens automatically (1:1 with supplied amount)

Withdraw Flow

1. Resolve the Pool address and underlying token address.

2. Check aToken balance (= withdrawable amount):
   aBalance_raw = IERC20(aToken).balanceOf(user)

3. Execute withdraw:
   pool.withdraw(underlying, amount_raw, user)
   → aTokens are burned, underlying tokens sent to `user`

   For full withdrawal, pass type(uint256).max as amount:
   pool.withdraw(underlying, type(uint256).max, user)

Native ETH Handling

Aave V3 does not accept native ETH directly. To supply/withdraw native ETH, use the WrappedTokenGatewayV3 contract:

// Deposit native ETH (wraps to WETH internally)
function depositETH(address pool, address onBehalfOf, uint16 referralCode) external payable;

// Withdraw to native ETH (unwraps WETH internally)
// User must approve aWETH to the gateway first
function withdrawETH(address pool, uint256 amount, address to) external;

5. Aave V3 GraphQL API

Endpoint: https://api.v3.aave.com/graphql

Query Reserve APY

query {
  reserves {
    chain { name chainId }
    asset { underlying { symbol address } }
    summary { supplyApy { normalized } borrowApy { normalized } }
    canBorrow
    canSupply
  }
}

The supplyApy.normalized field returns the annualized supply rate as a decimal (e.g. 0.035 = 3.5% APY).

Aave V4

1. Overview

Aave V4 launched on Ethereum mainnet on 2026-03-30. It introduces a Hub-and-Spoke architecture: users interact with Spoke contracts, and funds flow to a shared Liquidity Hub. This replaces V3's per-chain isolated Pool model.

Key points:

• Users call supply() / withdraw() on a Spoke contract (not a Pool)
• Reserves are identified by reserveId (uint256) instead of asset address
• No referralCode parameter
• Three Hubs: Core, Prime, Plus — each Spoke is connected to one Hub
• Currently Ethereum only

Supported chains:

2. Hub & Spoke Registry

Hub Addresses (Ethereum)

Spoke Addresses (Ethereum)

Peripheral Contracts (Ethereum)

Token Addresses (Ethereum)

3. Spoke Contract Interface

Write Functions

// Supply `amount` of the reserve identified by `reserveId` on behalf of `onBehalfOf`
// Returns (suppliedAmount, mintedShares)
function supply(
    uint256 reserveId,
    uint256 amount,
    address onBehalfOf
) external returns (uint256, uint256);

// Withdraw `amount` of the reserve identified by `reserveId` on behalf of `onBehalfOf`
// Returns (withdrawnAmount, burnedShares)
function withdraw(
    uint256 reserveId,
    uint256 amount,
    address onBehalfOf
) external returns (uint256, uint256);

ERC-20 Approve (prerequisite for supply)

// Approve the Spoke contract to spend underlying tokens on behalf of msg.sender
IERC20(underlying).approve(spokeAddress, amount);

4. Operation Flows

Deposit Flow

1. Identify the target Spoke address and look up the reserveId for the asset (see Section 5).

2. Check user balance:
   balance_raw = IERC20(underlying).balanceOf(user)

3. Approve Spoke to spend underlying:
   IERC20(underlying).approve(spoke_address, amount_raw)

4. Execute supply:
   (suppliedAmount, mintedShares) = spoke.supply(reserveId, amount_raw, user)

Withdraw Flow

1. Identify the target Spoke address and look up the reserveId for the asset (see Section 5).

2. Execute withdraw:
   (withdrawnAmount, burnedShares) = spoke.withdraw(reserveId, amount_raw, user)
   → Underlying tokens are sent to `user`

Native ETH Handling

Aave V4 provides a Native Token Gateway for supplying/withdrawing native ETH without manual wrapping:

Gateway address: 0xe68ab4F90Fe026B9873F5F276eD2d7efBbbE42Be

5. Reserve ID Lookup

Aave V4 identifies reserves by reserveId (uint256), not by asset address. To obtain the reserveId for a given asset, perform a two-step on-chain lookup:

Function Signatures

// Step 1 — on the Hub contract
// Returns the Hub-internal asset ID for the given underlying token address
function getAssetId(address underlying) external view returns (uint256);

// Step 2 — on the Spoke contract
// Maps (hub, assetId) → reserveId used in supply()/withdraw()
function getReserveId(address hub, uint256 assetId) external view returns (uint256);

Lookup Example

hub_address   = <Hub address from Section 2>       // e.g. Core Hub
spoke_address = <Spoke address from Section 2>     // e.g. Main Spoke

// Step 1: get the Hub-internal asset ID
assetId   = hub.getAssetId(USDC_ADDRESS)

// Step 2: convert to Spoke-specific reserveId
reserveId = spoke.getReserveId(hub_address, assetId)

// Now use reserveId in supply()/withdraw()
spoke.supply(reserveId, amount, user)

Note: reserveId values are per-Spoke — the same underlying asset can have different reserveId values across different Spokes. Always look up the reserveId for the specific Spoke you intend to interact with.

Additional View Functions on Spoke

6. Aave V4 GraphQL API

Endpoint: https://api.v4.aave.com/graphql

Query Reserve APY

query {
  reserves {
    chain { name chainId }
    asset { underlying { symbol address } }
    summary { supplyApy { normalized } borrowApy { normalized } }
    canBorrow
    canSupply
  }
}

The supplyApy.normalized field returns the annualized supply rate as a decimal (e.g. 0.035 = 3.5% APY).

7. Key Differences from V3

Spark

1. Overview

Spark is a DeFi platform within the Sky (formerly MakerDAO) ecosystem, comprising two product lines:

• Spark Savings — ERC-4626 vaults (spUSDC, spUSDT, spETH, etc.) that optimize yield via the Spark Liquidity Layer
• SparkLend (Markets) — Aave V3 fork lending pool; supply assets to receive spTokens

Savings products span 6 chains; SparkLend is deployed only on Ethereum and Gnosis.

Supported chains:

---

2. Spark Savings — Vault Registry

Product categories:

• V2 Vaults (spUSDC, spUSDT, spETH) — Spark-native ERC-4626 vaults deploying strategies via the Liquidity Layer
• Legacy (sUSDS, sDAI) — Sky protocol Savings Rate wrappers (not listed here)

Only USDC / USDT / ETH / BTC related vaults are listed below.

spUSDC (Spark USDC Vault)

Note: Avalanche has spUSDC in the address registry. Base / Arbitrum / Optimism / Unichain have a different savings product (sUSDC) that is a USDS-backed wrapper, not a direct USDC vault.

sUSDC (Savings USDC — USDS-backed)

spUSDT (Spark USDT Vault — Ethereum only)

spETH (Spark ETH Vault — Ethereum only)

BTC

No Spark Savings vault exists for BTC.

---

3. Spark Savings — ERC-4626 Contract Interface

All Spark Savings vaults (spUSDC, spUSDT, spETH, sUSDC) implement the standard ERC-4626 interface.

Read Functions (view)

// Returns the address of the underlying ERC-20 asset
function asset() external view returns (address);

// Total amount of the underlying asset managed by the vault
function totalAssets() external view returns (uint256);

// Vault share balance of `account`
function balanceOf(address account) external view returns (uint256);

// Convert `shares` to asset amount (no fees, no slippage)
function convertToAssets(uint256 shares) external view returns (uint256);

// Convert `assets` to share amount (no fees, no slippage)
function convertToShares(uint256 assets) external view returns (uint256);

// Preview how many shares a deposit of `assets` would yield
function previewDeposit(uint256 assets) external view returns (uint256);

// Preview how many assets a redeem of `shares` would yield
function previewRedeem(uint256 shares) external view returns (uint256);

Write Functions (state-changing)

// Deposit `assets` of underlying token, mint shares to `receiver`
function deposit(uint256 assets, address receiver) external returns (uint256 shares);

// Withdraw exactly `assets`, burning shares from `owner`, sending assets to `receiver`
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);

// Redeem exactly `shares`, sending resulting assets to `receiver` (preferred for full withdrawal)
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);

ERC-20 Approve (prerequisite for deposit)

// Approve the vault to spend underlying tokens on behalf of msg.sender
IERC20(underlying).approve(vaultAddress, amount);

---

4. Spark Savings — Operation Flows

Deposit Flow

1. Query underlying token address:
   underlying = vault.asset()

2. Check user balance:
   balance_raw = IERC20(underlying).balanceOf(user)

3. Approve vault to spend underlying:
   IERC20(underlying).approve(vault_address, amount_raw)

4. Preview expected shares:
   expected_shares = vault.previewDeposit(amount_raw)

5. Execute deposit:
   shares = vault.deposit(amount_raw, receiver)

Withdraw Flow (prefer redeem)

Using redeem is preferred over withdraw because it operates on shares (which the user holds) rather than a specific asset amount, avoiding rounding issues.

1. Check user share balance:
   shares = vault.balanceOf(user)

2. Preview expected assets:
   expected_assets = vault.previewRedeem(shares)

3. Execute redeem:
   assets = vault.redeem(shares, receiver, owner)

Full Withdrawal

vault.redeem(vault.balanceOf(user), user, user)

Liquidity Notes

• No lock-up period
• V2 vaults retain ~10% idle liquidity for instant withdrawals
• Large withdrawals are handled via Savings Liquidity Intents (typically fulfilled within minutes)

---

5. SparkLend (Markets) — Pool & Token Registry

SparkLend is an Aave V3 fork deployed only on Ethereum and Gnosis.

Pool Addresses

Ethereum Token Reserves

Gnosis Token Reserves

Note: Gnosis does not have a WBTC reserve.

---

6. SparkLend — Pool Contract Interface

SparkLend uses the same interface as Aave V3 (it is an Aave V3 fork).

Read Functions (view)

// Returns reserve data including aToken address, liquidity index, current rates
function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);

// Returns user account data (total collateral, total debt, available borrows, etc.)
function getUserAccountData(address user) external view returns (
    uint256 totalCollateralBase,
    uint256 totalDebtBase,
    uint256 availableBorrowsBase,
    uint256 currentLiquidationThreshold,
    uint256 ltv,
    uint256 healthFactor
);

Write Functions (state-changing)

// Supply `amount` of `asset` on behalf of `onBehalfOf`; referralCode is currently inactive (pass 0)
function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;

// Supply with ERC-2612 permit (single tx approve + supply)
function supplyWithPermit(
    address asset, uint256 amount, address onBehalfOf, uint16 referralCode,
    uint256 deadline, uint8 permitV, bytes32 permitR, bytes32 permitS
) external;

// Withdraw `amount` of `asset` to `to`; pass type(uint256).max for full withdrawal
function withdraw(address asset, uint256 amount, address to) external returns (uint256);

ERC-20 Approve (prerequisite for supply)

// Approve the Pool to spend underlying tokens on behalf of msg.sender
IERC20(underlying).approve(poolAddress, amount);

---

7. SparkLend — Operation Flows

Deposit (Supply) Flow

1. Check user balance:
   balance_raw = IERC20(underlying).balanceOf(user)

2. Approve Pool to spend underlying:
   IERC20(underlying).approve(pool_address, amount_raw)

3. Execute supply:
   pool.supply(underlying, amount_raw, user, 0)
   // referralCode = 0 (inactive)

Withdraw Flow

1. Check user spToken balance:
   sp_balance = IERC20(spToken).balanceOf(user)

2. Execute withdraw:
   pool.withdraw(underlying, amount_raw, user)

Full Withdrawal

pool.withdraw(underlying, type(uint256).max, user)

Native ETH via WETH Gateway

For native ETH deposits/withdrawals, use the WETH Gateway contract instead of the Pool directly:

// Deposit native ETH
IWETHGateway(gateway).depositETH{value: amount}(pool_address, onBehalfOf, 0);

// Withdraw to native ETH (requires spWETH approval to gateway)
IWETHGateway(gateway).withdrawETH(pool_address, amount, to);

---

8. Spark API

• No dedicated REST/GraphQL API (unlike Aave or Morpho)
• Rate queries: via on-chain getReserveData() or The Graph subgraph
• Savings rates: via ERC-4626 convertToAssets() method or SSR Oracle

---

9. Data Sources

All contract addresses sourced from:

• github.com/sparkdotfi/spark-address-registry (Ethereum.sol, Base.sol, Arbitrum.sol, Optimism.sol, Unichain.sol, Gnosis.sol)
• github.com/marsfoundation/sparklend-deployments (primary-latest.json for chain 1 and 100)
• Etherscan / GnosisScan verification

Morpho

1. Overview

Morpho V2 vaults are ERC-4626 standard tokenized vaults. Users deposit an underlying asset (e.g. USDC) and receive vault shares representing their proportional claim on the vault's total assets.

Supported chains:

---

2. Vault Registry

All vaults below are Morpho V2; V1 is excluded.

USDC Vaults

USDT Vaults

ETH Vaults

BTC Vaults

---

3. ERC-4626 Contract Interface

All Morpho V2 vaults implement the ERC-4626 standard. Below are the core function signatures.

Read Functions (view)

// Returns the address of the underlying ERC-20 asset
function asset() external view returns (address);

// Total amount of the underlying asset managed by the vault
function totalAssets() external view returns (uint256);

// Vault share balance of `account`
function balanceOf(address account) external view returns (uint256);

// Convert `shares` to asset amount (no fees, no slippage)
function convertToAssets(uint256 shares) external view returns (uint256);

// Convert `assets` to share amount (no fees, no slippage)
function convertToShares(uint256 assets) external view returns (uint256);

// Preview how many shares a deposit of `assets` would yield
function previewDeposit(uint256 assets) external view returns (uint256);

// Preview how many assets a redeem of `shares` would yield
function previewRedeem(uint256 shares) external view returns (uint256);

Write Functions (state-changing)

// Deposit `assets` of underlying token, mint shares to `receiver`
function deposit(uint256 assets, address receiver) external returns (uint256 shares);

// Withdraw exactly `assets`, burning shares from `owner`, sending assets to `receiver`
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);

// Redeem exactly `shares`, sending resulting assets to `receiver` (preferred for full withdrawal)
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);

ERC-20 Approve (prerequisite for deposit)

// Approve the vault to spend underlying tokens on behalf of msg.sender
IERC20(underlying).approve(vaultAddress, amount);

---

4. Operation Flows

Deposit Flow

1. Query underlying token address:
   underlying = vault.asset()

2. Check user balance:
   balance_raw = IERC20(underlying).balanceOf(user)

3. Approve vault to spend underlying:
   IERC20(underlying).approve(vault_address, amount_raw)

4. Preview expected shares:
   expected_shares = vault.previewDeposit(amount_raw)

5. Execute deposit:
   shares = vault.deposit(amount_raw, receiver)

Withdraw Flow (prefer redeem)

Using redeem is preferred over withdraw because it operates on shares (which the user holds) rather than a specific asset amount, avoiding rounding issues.

1. Check user share balance:
   shares = vault.balanceOf(user)

2. Preview expected assets:
   expected_assets = vault.previewRedeem(shares)

3. Execute redeem:
   assets = vault.redeem(shares, receiver, owner)

Full Withdrawal

vault.redeem(vault.balanceOf(user), user, user)

---

5. Morpho GraphQL API

Endpoint: https://api.morpho.org/graphql

Query Vault APY

query {
  vaultByAddress(address: "0xBEeFF047C03714965a54b671A37C18beF6b96210", chainId: 1) {
    address
    symbol
    asset {
      symbol
      decimals
      address
    }
    state {
      totalAssets
      apy
      netApy
    }
  }
}

Batch Query (all tracked vaults)

Use multiple vaultByAddress calls with GraphQL aliases:

query {
  steakhouseUSDC: vaultByAddress(address: "0xBEeFF047C03714965a54b671A37C18beF6b96210", chainId: 1) {
    address
    symbol
    state { apy netApy totalAssets }
  }
  skymoneyUSDC: vaultByAddress(address: "0x56bfa6f53669B836D1E0Dfa5e99706b12c373ecf", chainId: 1) {
    address
    symbol
    state { apy netApy totalAssets }
  }
  # ... add remaining vaults
}