Detailed Instructions

aTokens are Aave's interest-bearing tokens that represent a user's deposit in the protocol. Unlike traditional tokens, your aToken balance increases over time as interest accrues, directly in your wallet. This is known as a rebasing model. The key is that 1 aToken is always equal to 1 unit of the underlying asset, plus its accrued interest. For example, if you deposit 100 DAI, you receive 100 aDAI. Over time, your aDAI balance will grow to, say, 102.5 aDAI, which you can redeem for 102.5 DAI. This differs from cTokens (Compound's model), where your token balance stays constant but the exchange rate between the cToken and the underlying asset increases.

• Sub-step 1: Identify the token contract. For mainnet, the aDAI contract address is 0x028171bCA77440897B824Ca71D1c56caC55b68A3. You can view it on Etherscan.
• Sub-step 2: Check your balance. Use the balanceOf function on the aToken contract, passing your wallet address (e.g., 0x...). This returns your current, rebased aToken balance.
• Sub-step 3: Understand the liquidity index. The protocol uses a liquidity index that accumulates interest. Your balance is calculated as your initial deposit scaled by the growth of this index.

Tip: The rebasing happens automatically on every interaction (deposit, withdraw, transfer) with the protocol, updating your visible balance.

Detailed Instructions

The rebasing is managed by the AToken smart contract and the underlying LendingPool. The core value is the liquidityIndex, a public variable that increases over time as interest accrues. Your aToken balance is not stored directly; instead, the contract stores your scaled balance (your initial deposit amount) and multiplies it by the current liquidityIndex to get your actual balance. You can query this directly. The formula is: currentBalance = scaledBalance * liquidityIndex / 10^27. The index is expressed in RAY (a 27-decimal unit).

• Sub-step 1: Get the current liquidity index. Call the getReserveData function on the LendingPool contract (0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9 for mainnet) for your asset. It returns a tuple; the liquidity index is one element.
• Sub-step 2: Calculate your scaled balance. Call the scaledBalanceOf function on the aToken contract for your address.
• Sub-step 3: Compute your actual balance. Perform the multiplication: scaledBalance * liquidityIndex / 1e27.

javascriptCopy
// Example using ethers.js
const aTokenContract = new ethers.Contract(aTokenAddress, aTokenABI, provider);
const scaledBal = await aTokenContract.scaledBalanceOf(userAddress);
const liquidityIndex = await lendingPoolContract.getReserveData(assetAddress).then(data => data.liquidityIndex);
const actualBalance = scaledBal.mul(liquidityIndex).div(ethers.BigNumber.from(10).pow(27));

Tip: The liquidityIndex starts at 1e27 (represented as 1000000000000000000000000000) and only increases.

Detailed Instructions

Compound's cTokens use a different model. When you deposit, you receive cTokens (e.g., cDAI), but your cToken balance stays constant. Instead, the exchange rate between cTokens and the underlying asset increases over time. To get your underlying balance, you multiply your cToken balance by the current exchangeRateCurrent(). For example, you might deposit 100 DAI and receive 5000 cDAI (at an initial exchange rate of 0.02). Later, the exchange rate might rise to 0.0205, meaning your 5000 cDAI are now worth 102.5 DAI. This contrasts with Aave's model where the token quantity changes.

• Sub-step 1: Locate the cToken contract. For mainnet cDAI, the address is 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643.
• Sub-step 2: Check the exchange rate. Call the exchangeRateCurrent() function. It returns the amount of underlying assets one cToken is worth, scaled by 10^(18 - 8 + underlyingDecimals). For DAI, it's exchangeRate * balance / 1e28.
• Sub-step 3: Calculate underlying value. Use the formula: underlyingBalance = (cTokenBalance * exchangeRate) / (10^(18 + underlyingDecimals - cTokenDecimals)).

solidityCopy
// Example Solidity view
interface ICErc20 {
    function exchangeRateCurrent() external returns (uint);
    function balanceOf(address) external view returns (uint);
}
// After calling, compute: (cTokenBalance * exchangeRate) / 1e28 for cDAI.

Tip: The key difference is user experience: Aave shows growing balances in wallets, while Compound requires checking an exchange rate.

Detailed Instructions

Any transaction that calls the Aave protocol will trigger a balance rebase for the involved users. The _burn and _mint functions in the AToken contract handle updating the user's scaled balance based on the latest liquidityIndex. When you deposit 100 DAI, the protocol mints you 100 / (liquidityIndex / 1e27) scaled balance units. When you later withdraw, it burns your scaled balance and gives you scaledBalance * liquidityIndex / 1e27 underlying tokens. Transfers of aTokens also trigger a rebase for both sender and receiver before the transfer occurs, ensuring interest is accounted for up to that block.

• Sub-step 1: Deposit via the LendingPool. Call deposit(asset, amount, onBehalfOf, referralCode) on the LendingPool contract. Your aToken balance will update immediately.
• Sub-step 2: Withdraw assets. Call withdraw(asset, amount, to) on the LendingPool. Specify the maximum uint256 to withdraw everything.
• Sub-step 3: Transfer aTokens. Simply transfer aTokens like any ERC-20 using transfer(to, amount). The contract's _beforeTokenTransfer hook will update both parties' balances.

bashCopy
# Example deposit via Aave CLI (conceptual)
aave-cli deposit --asset DAI --amount 100 --on-behalf-of YOUR_ADDRESS

Tip: Because transfers rebase, sending aTokens to a new wallet automatically credits the sender with accrued interest up to that moment and starts accruing for the receiver from that point.

Detailed Instructions

To monitor interest accrual, you need to track the liquidity index over time. Since your scaled balance is fixed between interactions, the growth in your actual balance is purely driven by the index. You can fetch historical index values from blockchain events or subgraphs. The Aave protocol emits a ReserveDataUpdated event from the LendingPool whenever the index updates (along with liquidity and variable borrow rates). The index increases continuously with each block, proportional to the liquidity rate (the yield earned by depositors).

• Sub-step 1: Query historical events. Use Etherscan's event logs for the LendingPool, filtering for ReserveDataUpdated for your asset (e.g., DAI address 0x6B175474E89094C44Da98b954EedeAC495271d0F). Extract the liquidityIndex from the event data.
• Sub-step 2: Use The Graph subgraph. Query the Aave V2 subgraph (hosted service) for Reserve entities and their liquidityIndex history.
• Sub-step 3: Calculate APY. The approximate deposit APY can be derived from the index growth over a period: APY = ((index_t1 / index_t0) - 1) * (seconds_per_year / seconds_elapsed).

graphqlCopy
# Example GraphQL query for Aave V2 subgraph
{
  reserve(id: "0x6b175474e89094c44da98b954eedeac495271d0f") {
    liquidityIndex
    aToken {
      id
    }
  }
}

Tip: For real-time tracking, wallets and dashboards like Aave's UI automatically calculate and display your growing balance by reading the on-chain index.

Detailed Instructions

cTokens (Compound Tokens) and aTokens (Aave Tokens) are interest-bearing tokens that represent a user's share in a liquidity pool. When you deposit an asset like DAI into Compound, you receive cDAI. This token is not a 1:1 representation of your deposit; instead, its value relative to the underlying asset increases over time as interest accrues. The key mechanism is the exchange rate, which defines how many underlying tokens one cToken is worth. For example, if the exchange rate for cDAI is 1.05, then 1 cDAI can be redeemed for 1.05 DAI. This rate compounds every block, making it a dynamic value.

• Sub-step 1: Identify the contract: Locate the cToken contract, such as cDAI at address 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643 on Ethereum mainnet.
• Sub-step 2: Query the exchange rate: Use the exchangeRateCurrent() or exchangeRateStored() function to get the current rate.
• Sub-step 3: Calculate underlying value: Multiply your cToken balance by the exchange rate to find your redeemable underlying amount.

Tip: The exchangeRateStored() is a gas-efficient view function that returns the rate from the last accrued interest, while exchangeRateCurrent() accrues interest first for the most accurate, up-to-date value.

Detailed Instructions

The exchange rate is the engine of value accrual. It is calculated as (totalCash + totalBorrows - totalReserves) / totalSupply. Here, totalCash is the underlying balance in the contract, totalBorrows is the amount lent out plus accrued interest, totalReserves are protocol reserves, and totalSupply is the total cTokens in circulation. Interest accrues via the borrow rate, determined by the pool's utilization. Each time a transaction interacts with the protocol (like a mint, redeem, borrow, or repay), the accrueInterest() function is called, which updates the totalBorrows and reserves based on the time elapsed since the last accrual, thereby increasing the exchange rate.

• Sub-step 1: Inspect the accrual function: Review the accrueInterest() logic in the cToken contract.
• Sub-step 2: Calculate the rate increase: The borrow interest accrued per block is borrowRate * blockDelta * totalBorrows.
• Sub-step 3: Observe the growth: After accrual, the numerator (totalCash + totalBorrows - totalReserves) increases, raising the exchange rate for all holders.

Tip: You can simulate accrual off-chain using the public borrowRatePerBlock() and supplyRatePerBlock() view functions to estimate growth.

Detailed Instructions

To deposit assets, you call the mint() function, sending underlying tokens to the cToken contract. The amount of cTokens you receive is calculated as underlyingAmount / exchangeRateCurrent(). Conversely, to withdraw, you call redeem() or redeemUnderlying(), specifying either the cToken amount to burn or the underlying amount to receive. The contract uses the current exchange rate to perform the conversion. For example, minting 100 DAI when the exchange rate is 1.05 would give you approximately 100 / 1.05 = 95.24 cDAI. This cToken balance is your fungible, transferable claim on the pool.

• Sub-step 1: Mint cTokens: Call cToken.mint(100000000000000000000) to deposit 100 DAI (with 18 decimals).
• Sub-step 2: Check your balance: Use cToken.balanceOf(yourAddress) to see your cToken holdings.
• Sub-step 3: Redeem underlying assets: Call cToken.redeemUnderlying(50000000000000000000) to withdraw 50 DAI, burning the equivalent cTokens.

javascriptCopy
// Example mint call using ethers.js
await cDAIContract.mint(ethers.utils.parseUnits("100", 18));

Tip: Always approve the cToken contract to spend your underlying tokens (e.g., DAI) before calling mint().

Detailed Instructions

While both models achieve the same goal of interest accrual, their mechanisms differ. Compound's cTokens use a rising exchange rate with a static cToken balance. Your wallet balance of cDAI stays the same, but each unit becomes worth more DAI over time. In contrast, Aave's aTokens employ a rebasing model where your wallet balance of aDAI increases directly with each block, while the exchange rate with the underlying asset (like DAI) remains fixed at 1:1. This is because aTokens are pegged and the interest is distributed as more aTokens. The key difference is in accounting: cTokens are like shares in a fund whose NAV increases, while aTokens are like a direct, growing IOU.

• Sub-step 1: Check aToken balance: Query aDAI.balanceOf(yourAddress) to see a balance that increases every second.
• Sub-step 2: Check cToken value: For cDAI, you must multiply balanceOf() by exchangeRateCurrent() to see your true underlying value.
• Sub-step 3: Analyze gas implications: cToken interest accrual is lazy (on interaction), while aToken rebasing is handled by the protocol continuously, though gas costs for transfers differ.

Tip: For developers, integrating cTokens requires on-chain exchange rate queries for accurate pricing, while aToken balances can be used directly at face value.