DeFi借贷概念 #1 – 借与贷

  • A+
所属分类:Defi

chatGPT账号

这篇文章是借贷系列文章的一篇,在这篇文章里,我们回顾 DeFi 协议如何进行借贷。

我们见讨论DeFi借贷协议如何工作, 它们的关键组成部分、公式和使用案例。在这个过程中,我们将强调,尽管各协议有不同的命名,协议往往使用类似的的核心概念。我们在这篇博文中详细写到的一个这样的共享核心概念实现,就是使用ERC20代币来代表用户在借贷池中的份额。我们将首先强调这些协议的独特概念元素,并提供技术概念来区分它们的工作方式。

阅读完本文,将了解到以下概念:

  • 借贷池
  • 份额币(Share Token)
  • aToken:AAVE 的份额币
  • cToken:Compound 的份额币
  • eToken:Euler 的份额币。

借贷池(Lending Pools)

在传统金融(或TradFi)中,借贷是由第三方的金融机构来调解的。这些金融机构被赋予两个关键任务:强制借款方向贷款方支付利息,以及评估和防止被认为不值得信任的各方参与这些活动。

相比之下,在去中心化金融(或DeFi)中,第三方贷款人和借款人是不被信任的(没有担保)。这种缺乏信任的情况激发了一种促进链上借贷过程的新颖设计。

一个借贷池是一个智能合约。DeFi协议的用户可以存入资产(通常是ERC20代币),目的是使用这个合约来借出他们存入的资产。其他用户可以与借贷池交互,享受即时贷款--用存入池中的抵押资产进行借贷。

与传统的金融方法相比,借贷池有一些重大的好处,比如说:

  • 通过DeFi,贷款不受借出资金与借入金额1:1的可用性限制。相反,来自该协议所有用户的资金被存入资金池--从而创造出足够大的代币库存,以立即满足贷款需求。
  • DeFi摒弃了还款时间表。贷款是使用以前存入代币作为抵押品,用户可以选择在任何时候偿还。

在这一点上,你可能会想:"如果我必须提供同等价值(甚至更高估值)的资产作为抵押,我为什么要在借贷协议上借入资产?我不是应该卖掉抵押品,然后买下借来的资产吗?"

不是的,看上去DeFi借贷协议似乎只允许完全(或超额)抵押的贷款,但这为一种有趣的 "交易 "方法打开了大门:杠杆交易。

想象一下,你看好WBTC--100%肯定它的价值会暴涨!你可以存入一些WBTC(比如说,你可以把WBTC存入银行)!你可以在你最喜欢的贷款协议上存入一些WBTC(比如价值1000美元),用它来借一些稳定币(即USDC),然后你可以在一些交易所购买更多的WBTC(在我们的场景中,让我们假设你初始存款的一半--500美元)。在此案例中,你将从最初的1000美元中获得1500美元的WBTC风险资金。

但是,等等,还有更多!如果你将价值500美元的WBTC抵押品存入,并以其为抵押借入更多的USDC呢?这个过程被称为过度杠杆化,你可以反复这样做,直到协议的政策停止这样做,一旦你超过了你的借贷能力。

在类似情况下,假设你看跌WBTC(毕竟现在是加密货币的冬天❄️)。你可以采取与之前的方案相反的做法,存入USDC作为抵押品来借入WBTC,并立即卖出 WBTC 以获得更多的稳定币。如果你的预测如实,WBTC的价格下跌,那么你可以在交易所以更低的价格买入相同数量的WBTC ,偿还你的债务,多余的USDC则是自己的利润

份额币(Share Tokens)

与TradFi一样,将资产存入借贷池的用户被激励将其资金长期保留在借贷池中,他们的存款会产生利息。利息随着时间的推移而累积,协议按用户在借贷池中的存款比例来计算,并由其各自的存款用户索取。用户在借贷池中保持其资产的时间越长,他们应计的利息就越多。

协议是如何核算每个用户在池子里的份额的?请记住,当一个用户将资产存入资金池时,他们的 "份额" 会稀释所有用户的份额,协议也会相应地反映这一点。然而,协议并不直接跟踪和更新每个用户在资金池中的份额,在每一次提款或存款的时候。在链上这样做会造成巨大的浪费,而且对储户来说成本过高,储户得为每次更新动作买单。

相反,该协议被设计为只处理储户份额的变化,而不需要主动更新其他用户的份额。

协议通过铸造和燃烧ERC20代币来处理利息的发行,我们将其称为 "份额币(Share Tokens)",代表贷款人在其贷款池中的份额(或标的资产存款的比例)。"份额币 "的设计会自动调整其他 "股东(存款人)" 的股份稀释,以反映 "股份" 的铸造和燃烧,分别与他们的标的资产的存入或提取对应。

下面,我们将提供不同协议采用 "份额币" 的真实例子,并讨论其相似性。

aToken:AAVE 的份额币

aToken 是 AAVE 的可产生收益的代币,由借贷池在向协议存入和提取资产时分别铸造和燃烧。

aToken 是AAVE协议中的类似ERC20的代币,这样,用户可以进入的每个市场都有一个aToken(将抵押品存入)

每个 aToken 合约对应一个市场

如果我们看一下 AAVE 借贷池合约,可以看到当用户将资产存入池中时发生的底层操作:

pragma solidity ^0.8.13;

function deposit(
  address asset,
  uint256 amount,
  address onBehalfOf,
  uint16 referralCode
) external override whenNotPaused {
  DataTypes.ReserveData storage reserve = _reserves[asset];

  ValidationLogic.validateDeposit(reserve, amount);

  address aToken = reserve.aTokenAddress;

  reserve.updateState();
  reserve.updateInterestRates(asset, aToken, amount, 0);

  IERC20(asset).safeTransferFrom(msg.sender, aToken, amount);

  bool isFirstDeposit = IAToken(aToken).mint(onBehalfOf, amount, reserve.liquidityIndex);

  if (isFirstDeposit) {
    _usersConfig[onBehalfOf].setUsingAsCollateral(reserve.id, true);
    emit ReserveUsedAsCollateralEnabled(asset, onBehalfOf);
  }

  emit Deposit(asset, msg.sender, onBehalfOf, amount, referralCode);
}

我们可以看到,与用户存入的市场相对应的aToken将被调用,并有mint函数。

pragma solidity ^0.8.13;

function mint(
  address user,
  uint256 amount,
  uint256 index
) external override onlyLendingPool returns (bool) {
  uint256 previousBalance = super.balanceOf(user);

  uint256 amountScaled = amount.rayDiv(index);
  require(amountScaled != 0, Errors.CT_INVALID_MINT_AMOUNT);
  _mint(user, amountScaled);

  emit Transfer(address(0), user, amount);
  emit Mint(user, amount, index);

  return previousBalance == 0;
}

我们可以看到,实际要铸造的数量是:

DeFi借贷概念 #1 - 借与贷

在我们的例子中,用户已经加入的市场,其储备已经在他们之前存入的资产上累积了一些利息。上面的等式有助于我们理解这一点,因为它显示了如何用一个在各种行动(存款、取款等)中更新的全局指数来说明所有用户的利息累积

译者注:liquidityIndex 是一个累积量,理解这一点很关键

当用户提取他们的标的资产时,liquidityIndex 被用作一个乘数来计算交易中所持有的代币数量。

下面是借贷池合约取款的相关代码片段:

pragma solidity ^0.8.13;

function withdraw(
  address asset,
  uint256 amount,
  address to
) external override whenNotPaused returns (uint256) {
  DataTypes.ReserveData storage reserve = _reserves[asset];

  address aToken = reserve.aTokenAddress;

  uint256 userBalance = IAToken(aToken).balanceOf(msg.sender);

  uint256 amountToWithdraw = amount;

  if (amount == type(uint256).max) {
    amountToWithdraw = userBalance;
  }

  ValidationLogic.validateWithdraw(
    asset,
    amountToWithdraw,
    userBalance,
    _reserves,
    _usersConfig[msg.sender],
    _reservesList,
    _reservesCount,
    _addressesProvider.getPriceOracle()
  );

  reserve.updateState();

  reserve.updateInterestRates(asset, aToken, 0, amountToWithdraw);

  if (amountToWithdraw == userBalance) {
    _usersConfig[msg.sender].setUsingAsCollateral(reserve.id, false);
    emit ReserveUsedAsCollateralDisabled(asset, msg.sender);
  }

  IAToken(aToken).burn(msg.sender, to, amountToWithdraw, reserve.liquidityIndex);

  emit Withdraw(asset, msg.sender, to, amountToWithdraw);

  return amountToWithdraw;
}


在这里,aToken合约的balanceOf功能是很奇怪的! 毕竟,我们刚刚确定,铸造的aTokens的数量与存入的标的资产的数量有偏差。为什么调用IAToken(aToken).balanceOf(address(user))会产生要提取的标的资产的数量(如函数底部所示)? 是这样的:

  • 当用户提取他们的资产时,其对应的aTokens被销毁。这些 aTokens 被销毁后,其他用户拥有的 aTokens 总量与他们在用户资产被提取后在资金池中的份额依旧成正比。
  • 用户提取资金的市场的利率随着每次提取而更新。

DeFi借贷概念 #1 - 借与贷

正如我们之前介绍的,aTokens是类似ERC20的代币。我们强调它们 像 ERC-20代币,是因为它的 balanceOf 函数有独特属性。在常规的ERC20代币中,balanceOf函数仅是返回一个地址拥有的代币数量。

因为aToken代表了资金池的份额,而不是直接的价值,aTokenbalanceOf函数返回协议”欠“用户的标的(underlying)代币的数量,用于他们的存款。

pragma solidity ^0.8.13;

function balanceOf(address user)
  public
  view
  override(IncentivizedERC20, IERC20)
  returns (uint256)
{
  return super.balanceOf(user).rayMul(_pool.getReserveNormalizedIncome(_underlyingAsset));
}

这里,这个balanceOf函数重写了被继承的aToken合约中的balanceOf。因此,这个例子的balanceOf逻辑被执行,而不是被继承的的token数量的映射查询。

上面提到的代币数量然后乘以 getReserveNormalizedIncome的结果,它执行了以下逻辑:

pragma solidity ^0.8.13;

function getNormalizedIncome(DataTypes.ReserveData storage reserve)
  internal
  view
  returns (uint256)
{
  uint40 timestamp = reserve.lastUpdateTimestamp;

  if (timestamp == uint40(block.timestamp)) {
    return reserve.liquidityIndex;
  }

  uint256 cumulated =
    MathUtils.calculateLinearInterest(reserve.currentLiquidityRate, timestamp).rayMul(
      reserve.liquidityIndex
    );

  return cumulated;
}

我们可以分析这里的分支条件:

  • 如果在该块中已经发生了对储备金数据的更新:返回该市场的liquidityIndex值,因为它已经被更新。
  • 否则:我们需要看看在calculateLinearInterest中发生了什么,以找出要执行的下一个流程

 

pragma solidity ^0.8.13;

function calculateLinearInterest(uint256 rate, uint40 lastUpdateTimestamp)
  internal
  view
  returns (uint256)
{
  uint256 timeDifference = block.timestamp.sub(uint256(lastUpdateTimestamp));

  return (rate.mul(timeDifference) / SECONDS_PER_YEAR).add(WadRayMath.ray());
}

市场的ReserveData对象中的currentLiquidityRatelastUpdateTimestamp被传入这个函数,结果将是:

DeFi借贷概念 #1 - 借与贷

让我们来分解这个等式的组成部分,以更好地理解linearInterest值的要点:

  • currentLiquidityRate:可以把它看作是我们所在市场的APY(Annual Percentage Yield :年化收益率)。
  • block_{timestamp}- lastUpdatedTimestamp:自上次更新以来的时间。

注意:由于我们在getNormalizedIncome中的第2个语句,所以保证这个值在此时是正数!

因此,我们可以把这种应计利息的机制看作是一种简单的利息复利机制,每一个区块都是复利

现在我们已经确定了用户的应计利息金额,我们只需要将这个值乘以 liquidityIndex(流动性指数),就可以得到用户的正常收入(NormalizedIncome),在balanceOf函数中相乘:

DeFi借贷概念 #1 - 借与贷

现在我们理解了aToken背后的逻辑,但我们仍然要解决liquidityIndex如何工作的。

在下面的例子中,流动性指数可以定义为储备金在一定时期内积累的利息:

pragma solidity ^0.8.13;

function _updateIndexes(
  DataTypes.ReserveData storage reserve,
  uint256 scaledVariableDebt,
  uint256 liquidityIndex,
  uint256 variableBorrowIndex,
  uint40 timestamp
) internal returns (uint256, uint256) {
  uint256 currentLiquidityRate = reserve.currentLiquidityRate;

  uint256 newLiquidityIndex = liquidityIndex;
  uint256 newVariableBorrowIndex = variableBorrowIndex;

  if (currentLiquidityRate > 0) {
    uint256 cumulatedLiquidityInterest =
      MathUtils.calculateLinearInterest(currentLiquidityRate, timestamp);
    newLiquidityIndex = cumulatedLiquidityInterest.rayMul(liquidityIndex);
    require(newLiquidityIndex <= type(uint128).max, Errors.RL_LIQUIDITY_INDEX_OVERFLOW);

    reserve.liquidityIndex = uint128(newLiquidityIndex);

    if (scaledVariableDebt != 0) {
      uint256 cumulatedVariableBorrowInterest =
        MathUtils.calculateCompoundedInterest(reserve.currentVariableBorrowRate, timestamp);
      newVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul(variableBorrowIndex);
      require(
        newVariableBorrowIndex <= type(uint128).max,
        Errors.RL_VARIABLE_BORROW_INDEX_OVERFLOW
      );
      reserve.variableBorrowIndex = uint128(newVariableBorrowIndex);
    }
  }

  reserve.lastUpdateTimestamp = uint40(block.timestamp);
  return (newLiquidityIndex, newVariableBorrowIndex);
}
}

回顾之前的 liquidityRate变量 -- 现在我们将讨论它在 "liquidityIndex "的计算。只有当 "liquidityRate" 大于0时,才会有利息的积累,换句话说,只有在该市场有APY的情况下。这是有道理。

让我们快速回顾一下calculateLinearInterest的实际作用:

pragma solidity ^0.8.13;

function calculateLinearInterest(uint256 rate, uint40 lastUpdateTimestamp)
  internal
  view
  returns (uint256)
{
  uint256 timeDifference = block.timestamp.sub(uint256(lastUpdateTimestamp));

  return (rate.mul(timeDifference) / SECONDS_PER_YEAR).add(WadRayMath.ray());
}

上述逻辑可转化为以下方程式:

DeFi借贷概念 #1 - 借与贷

正如我们在DefaultReserveInterestRateStrategy.sol合约中看到的,liquidityRate 的定义是:


pragma solidity ^0.8.13;

function calculateInterestRates(
    address _reserve,
    uint256 _availableLiquidity,
    uint256 _totalBorrowsStable,
    uint256 _totalBorrowsVariable,
    uint256 _averageStableBorrowRate
)
    external
    view
    returns (
        uint256 currentLiquidityRate,
        uint256 currentStableBorrowRate,
        uint256 currentVariableBorrowRate
    )
{

uint256 utilizationRate = (totalBorrows == 0 && _availableLiquidity == 0)
      ? 0
      : totalBorrows.rayDiv(_availableLiquidity.add(totalBorrows));

// ...

currentLiquidityRate = getOverallBorrowRateInternal(
        _totalBorrowsStable,
        _totalBorrowsVariable,
        currentVariableBorrowRate,
        _averageStableBorrowRate
    )
        .rayMul(utilizationRate);

}

因此,它可以写成:

DeFi借贷概念 #1 - 借与贷

这里又定义了 "总体借贷率"(overallBorrowRate):

pragma solidity ^0.8.13;

function getOverallBorrowRateInternal(
    uint256 _totalBorrowsStable,
    uint256 _totalBorrowsVariable,
    uint256 _currentVariableBorrowRate,
    uint256 _currentAverageStableBorrowRate
) internal pure returns (uint256) {
    uint256 totalBorrows = _totalBorrowsStable.add(_totalBorrowsVariable);

    if (totalBorrows == 0) return 0;

    uint256 weightedVariableRate = _totalBorrowsVariable.wadToRay().rayMul(
        _currentVariableBorrowRate
    );

    uint256 weightedStableRate = _totalBorrowsStable.wadToRay().rayMul(
        _currentAverageStableBorrowRate
    );

    uint256 overallBorrowRate = weightedVariableRate.add(weightedStableRate).rayDiv(
        totalBorrows.wadToRay()
    );

    return overallBorrowRate;
}
}


而我们可以把它写成:

DeFi借贷概念 #1 - 借与贷

DeFi借贷概念 #1 - 借与贷

而 "利用率utilizationRate" 可以被定义为:

DeFi借贷概念 #1 - 借与贷

在定义利用率时,更容易想到它是储备中的流动性(目前借来的)与市场上总的流动性之间的比率,可以简化为:

DeFi借贷概念 #1 - 借与贷

现在我们可以用这两个定义来写下流动性比率(liquidity rate)的方程式:

DeFi借贷概念 #1 - 借与贷

由于 totalBorrows 在分子和分母中都有,我们可以推出:

DeFi借贷概念 #1 - 借与贷

现在,我们对 "流动性比率"的公式的阐述就到此为止。我们以后会再来讨论这个定义。

cToken:Compound 的份额币

让我们继续看下一个借贷协议的例子:Compound。

Compound使用一个叫做 "cToken" 的份额币来处理借贷。这个代币为Compound协议中用户可用于借贷的所有资产进行记账。

与我们讨论的 AAVE V2 类似,Compound的 "份额币" 被铸造并用于赎回标的资产。

Compound使用一个兑换率(exchange rate),类似于AAVE V2的流动性指数,来决定应该铸造多少cToken。这个兑换率是一个函数:


pragma solidity ^0.8.13;

function exchangeRateStoredInternal() internal view returns (MathError, uint) {
    uint _totalSupply = totalSupply;
    if (_totalSupply == 0) {
        return (MathError.NO_ERROR, initialExchangeRateMantissa);
    } else {
        uint totalCash = getCashPrior();
        uint cashPlusBorrowsMinusReserves;
        Exp memory exchangeRate;
        MathError mathErr;

        (mathErr, cashPlusBorrowsMinusReserves) = addThenSubUInt(totalCash, totalBorrows, totalReserves);
        if (mathErr != MathError.NO_ERROR) {
            return (mathErr, 0);
        }

        (mathErr, exchangeRate) = getExp(cashPlusBorrowsMinusReserves, _totalSupply);
        if (mathErr != MathError.NO_ERROR) {
            return (mathErr, 0);
        }

        return (MathError.NO_ERROR, exchangeRate.mantissa);
    }
}

让我们来解释一下这里的关键术语:

  • totalCash(在合约留下的数量):cToken 账户所拥有的ERC20 标的代币(underlying token)的数量。
  • totalBorrows(借出的总量):从市场借出给借款人的 ERC20 标的代币的数量。
  • totalReserves(总储备金):储备的 ERC20 标的代币的数量,可通过治理提取或转账。
  • totalSupply:ERC20函数,返回 cToken 的总发行量。

有了这个背景,我们可以写出Compound的兑换率方程:

DeFi借贷概念 #1 - 借与贷

当用户存入ERC20代币时, 兑换率决定了会有多少cToken被铸造出来作为回报:


pragma solidity ^0.8.13;

function mintFresh(address minter, uint mintAmount) internal returns (uint, uint) {
    uint allowed = comptroller.mintAllowed(address(this), minter, mintAmount);
    if (allowed != 0) {
        return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.MINT_COMPTROLLER_REJECTION, allowed), 0);
    }

    if (accrualBlockNumber != getBlockNumber()) {
        return (fail(Error.MARKET_NOT_FRESH, FailureInfo.MINT_FRESHNESS_CHECK), 0);
    }

    MintLocalVars memory vars;

    (vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();
    if (vars.mathErr != MathError.NO_ERROR) {
        return (failOpaque(Error.MATH_ERROR, FailureInfo.MINT_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr)), 0);
    }

    vars.actualMintAmount = doTransferIn(minter, mintAmount);

    (vars.mathErr, vars.mintTokens) = divScalarByExpTruncate(vars.actualMintAmount, Exp({mantissa: vars.exchangeRateMantissa}));
    require(vars.mathErr == MathError.NO_ERROR, "MINT_EXCHANGE_CALCULATION_FAILED");


    (vars.mathErr, vars.totalSupplyNew) = addUInt(totalSupply, vars.mintTokens);
    require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_TOTAL_SUPPLY_CALCULATION_FAILED");

    (vars.mathErr, vars.accountTokensNew) = addUInt(accountTokens[minter], vars.mintTokens);
    require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED");

    totalSupply = vars.totalSupplyNew;
    accountTokens[minter] = vars.accountTokensNew;

    emit Mint(minter, vars.actualMintAmount, vars.mintTokens);
    emit Transfer(address(this), minter, vars.mintTokens);

    return (uint(Error.NO_ERROR), vars.actualMintAmount);
}


而要铸造的cToken的数量由以下公式定义:

DeFi借贷概念 #1 - 借与贷

关于借贷协议利息的计算,还可参考: https://learnblockchain.cn/article/5036

eToken:Euler的份额币

为了进一步巩固这些协议的相似性,我们将分解另一个借贷协议: Euler,并看看它如何处理借贷。

在下面的例子中,存款函数让用户存入ERC20代币以换取......eToken


pragma solidity ^0.8.13;

function deposit(uint subAccountId, uint amount) external nonReentrant {
    (address underlying, AssetStorage storage assetStorage, address proxyAddr, address msgSender) = CALLER();
    address account = getSubAccount(msgSender, subAccountId);

    updateAverageLiquidity(account);
    emit RequestDeposit(account, amount);

    AssetCache memory assetCache = loadAssetCache(underlying, assetStorage);

    if (amount == type(uint).max) {
        amount = callBalanceOf(assetCache, msgSender);
    }

    amount = decodeExternalAmount(assetCache, amount);

    uint amountTransferred = pullTokens(assetCache, msgSender, amount);
    uint amountInternal;

    unchecked {
        assetCache.poolSize -= amountTransferred;
        amountInternal = underlyingAmountToBalance(assetCache, amountTransferred);
        assetCache.poolSize += amountTransferred;
    }

    increaseBalance(assetStorage, assetCache, proxyAddr, account, amountInternal);

    if (assetStorage.users[account].owed != 0) checkLiquidity(account);

    logAssetStatus(assetCache);
}


我们可以看到,internalAmount是为这次转账铸造的 eToken 的数量。

pragma solidity ^0.8.13;

function computeExchangeRate(AssetCache memory assetCache) private pure returns (uint) {
    uint totalAssets = assetCache.poolSize + (assetCache.totalBorrows / INTERNAL_DEBT_PRECISION);
    if (totalAssets == 0 || assetCache.totalBalances == 0) return 1e18;
    return totalAssets * 1e18 / assetCache.totalBalances;
}

function underlyingAmountToBalance(AssetCache memory assetCache, uint amount) internal pure returns (uint) {
    uint exchangeRate = computeExchangeRate(assetCache);
    return amount * 1e18 / exchangeRate;
}

然而,与Compound的另一个直接重合:exchangeRate的名称和功能。

DeFi借贷概念 #1 - 借与贷

让我们解释一下用于计算兑换率的关键参数:

  • poolSize:标的资产ERC20合约对应池子地址上的余额,即调用balanceOf(池子地址)的结果。
  • totalBorrows:借入的ERC20总量,目前不在资金池中。
  • totalBalances:所有 eToken 持有人的总余额。

因此,方程式将是:

DeFi借贷概念 #1 - 借与贷

小结

回顾一下,我们已经涵盖了3个借贷协议:

  • AAVE V2
  • Compound
  • Euler

我们已经研究了 "份额币" 的铸造,以及它们如何通过借贷池兑换成存款资产。

我们提出的三个方程显示了这些过程是如何工作的,可以归纳为这个简单的方程:

DeFi借贷概念 #1 - 借与贷

请记住,兑换率(exchange rate)可以用协议规定的任何方式来定义。在AAVE V2和Compound中,我们已经看到��������someRate变量的定义方式有一些相似之处。在Compound中,someRate是:

DeFi借贷概念 #1 - 借与贷

而在AAVE V2中,someRate 被定义为:

DeFi借贷概念 #1 - 借与贷

而 liquidity rate 定义为:

DeFi借贷概念 #1 - 借与贷

虽然我们不能概括每个协议的比率,但对于AAVE2和Compound,我们知道比率是市场上总流动性的函数。回到我们的方程上,鉴于 "总流动性(totalLiquidity)" 是市场上 ERC20 标的代币的总量,"兑换率(exchangeRate) "表达式中的分子和 liquidityRate 中的分母在功能上是一样的。

简单地说:这些协议实际上是相同的。虽然它们有时可能使用不同的术语,但当分解成方程式时,每个组件在执行中都有类似的目的。

免责声明

发文时比特币价格:$27249

当前比特币价格:[crypto coins=”BTC” type=”text” show=”price”]

当前比特币涨幅:[crypto coins=”BTC” type=”text” show=”percent”]

免责声明:

本文不代表路远网立场,且不构成投资建议,请谨慎对待。用户由此造成的损失由用户自行承担,与路远网没有任何关系;

路远网不对网站所发布内容的准确性,真实性等任何方面做任何形式的承诺和保障;

网站内所有涉及到的区块链(衍生)项目,路远网对项目的真实性,准确性等任何方面均不做任何形式的承诺和保障;

网站内所有涉及到的区块链(衍生)项目,路远网不对其构成任何投资建议,用户由此造成的损失由用户自行承担,与路远网没有任何关系;

路远区块链研究院声明:路远区块链研究院内容由路远网发布,部分来源于互联网和行业分析师投稿收录,内容为路远区块链研究院加盟专职分析师独立观点,不代表路远网立场。

本文是全系列中第68 / 152篇:行业技术

  • 我的微信
  • 这是我的微信扫一扫
  • weinxin
  • 我的电报
  • 这是我的电报扫一扫
  • weinxin
chatGPT账号
路远

发表评论

您必须登录才能发表评论!