AAVE 收益计算

/// @inheritdoc IERC20
function balanceOf(
  address user
) public view virtual override(IncentivizedERC20, IERC20) returns (uint256) {
  return super.balanceOf(user).rayMul(POOL.getReserveNormalizedIncome(_underlyingAsset));
}

/// @inheritdoc IPool
function getReserveNormalizedIncome(
  address asset
) external view virtual override returns (uint256) {
  return _reserves[asset].getNormalizedIncome();
}

/**
 * @notice Returns the ongoing normalized income for the reserve.
 * @dev A value of 1e27 means there is no income. As time passes, the income is accrued
 * @dev A value of 2*1e27 means for each unit of asset one unit of income has been accrued
 * @param reserve The reserve object
 * @return The normalized income, expressed in ray
 */
function getNormalizedIncome(
  DataTypes.ReserveData storage reserve
) internal view returns (uint256) {
  uint40 timestamp = reserve.lastUpdateTimestamp;

  //solium-disable-next-line
  if (timestamp == block.timestamp) {
    //if the index was updated in the same block, no need to perform any calculation
    return reserve.liquidityIndex;
  } else {
    return
      MathUtils.calculateLinearInterest(reserve.currentLiquidityRate, timestamp).rayMul(
        reserve.liquidityIndex
      );
  }
}

function getReserveData(address asset) external view virtual override returns (DataTypes.ReserveData memory)

package main

import (
  "context"
  "math/big"

  "github.com/ethereum/go-ethereum/common"
  "github.com/ethereum/go-ethereum/common/hexutil"
  "github.com/ethereum/go-ethereum/crypto"
  "github.com/ethereum/go-ethereum/rpc"
  "github.com/shopspring/decimal"
)

func getAAVELiquidityNetValue() (decimal.Decimal, error){
  assetAddress := common.HexToAddress("0xdAC17F958D2ee523a2206206994597C13D831ec7") // USDT
  fun := []byte("getReserveData(address)")
  hash := crypto.NewKeccakState()
  hash.Write(fun)
  methodID := hash.Sum(nil)[:4]

  var data []byte
  data = append(data, methodID...)
  data = append(data, common.LeftPadBytes(assetAddress.Bytes(), 32)...)
  callMsg := map[string]interface{}{
    "from": assetAddress,
    "to":   common.HexToAddress(aavePool),
    "data": hexutil.Bytes(data),
  }
  var result string
  rpcClient, err := rpc.DialHTTP(client.url)
  if err != nil {
    return decimal.Zero, err
  }
  err := rpcClient.CallContext(context.TODO(), &result, "eth_call", callMsg, nil)
  if err != nil {
    return decimal.Zero, err
  }
  bi := new(big.Int).SetBytes(common.FromHex(result[66 : 66+64]))
  return decimal.NewFromBigInt(bi, -27), nil
}

uint256 scaledBalance = AToken(asset_address).scaledBalanceOf(address(this));
uint256 value_now = (scaledBalance * liquidityIndex) * 1e18 / 1e27;