Maple Finance Schema Map

💡 The Schema Map defines the datasources, and their relation, and what creates and updates entities.

---

Event (not entity, but gets extended):

• Show data
  • id:
    • On creation: event.transaction.hash + “-” + Event.logIndex
  • hash
    • On creation: event.transaction.hash
  • logIndex:
    • On creation: event.logIndex
  • protocol:
    • On creation: PROTOCOL_ID
  • to:
    • On creation: event.transaction.to or event.transaction.from
    • Note: .to and .from depend on type of transaction
  • from:
    • On creation: event.transaction.from or event.transaction.to
    • Note: .to and .from depend on type of transaction
  • blockNumber:
    • On creation: event.block.number
  • timestamp:
    • On creation: event.block.timestamp

---

Deposit (immutable), extends Event: Pool.sol→Transfer

• filter on: Transfer.from == ZERO_ADDRESS (i.e mint of MPT)
• Show data
  • market:
    • On creation:
      • poolAddress = event.address
      • market = Market(poolAddress)
      • market.id
  • asset:
    • On creation: market.inputToken
  • _amountMPT:
    • On creation: Transfer.value
      • This gives the amount of maple pool tokens being minted
  • amount:
    • On creation: _amountMPT * market.exchangeRate
  • amountUSD:
    • On creation: amount * market.inputTokenPriceUSD

---

Withdraw (immutable), extends Event: Pool.sol→Transfer

• filter on: Transfer.to == ZERO_ADDRESS (i.e burn of MPT)
• Show data
  • market:
    • On creation:
      • poolAddress = event.address
      • market = Market(poolAddress)
      • market.id
  • asset:
    • On creation: market.inputToken
  • _amountMPT:
    • On creation: Transfer.value
      • This gives the amount of maple pool tokens being burned
  • amount:
    • On creation: _amountMPT * market.exchangeRate
  • amountUSD:
    • On creation: amount * market.inputTokenPriceUSD

---

Borrow (immutable), extends Event: Loan.sol→Drawdown (actual borrow “drawdown funds”)

• Show data
  • market:
    • On creation:
      • loanAddress = event.transaction.to
      • loan = _Loan(loanAddress)
      • poolAddress = loan.market.id
      • market = Market(poolAddress)
      • market.id
  • asset:
    • On creation: market.inputToken
  • amount:
    • On creation: Drawdown.drawdownAmount
  • amountUSD:
    • On creation: amount * market.inputTokenPriceUSD

---

Repay (immutable), extends Event: Loan.sol→PaymentMade

• Show data
  • market:
    • On creation:
      • loanAddress = event.transaction.to
      • loan = _Loan(loanAddress)
      • poolAddress = loan.market.id
      • market = Market(poolAddress)
      • market.id
  • asset:
    • On creation: market.inputToken
  • amount:
    • On creation: PaymentMade.totalPaid
  • amountUSD:
    • On creation: amount * market.inputTokenPriceUSD
  • _principalPaid:
    • On creation: PaymentMade.principalPaid
  • _interestPaid:
    • On creation: PaymentMade.interestPaid
  • _late:
    • On creation: PaymentMade.latePayment

---

Liquidate (immutable), extends Event: Loan.sol→Liquidation

• Show data
  • market:
    • On creation:
      • loanAddress = event.transaction.to
      • loan = _Loan(loanAddress)
      • poolAddress = loan.market.id
      • market = Market(poolAddress)
      • market.id
  • asset:
    • On creation: market.inputToken
  • amount: total liquidation amount including collateral and all defaults / losses
    • On creation: _amountRecoveredFromCollatoral + _defaultSufferedToPoolAndStake
  • amountUSD
    • On creation: amount * market.inputTokenPriceUSD
  • profitUSD: no one profits from liquidations in this protocol
    • On creation: 0
  • _amountRecoveredFromCollatoral: in pool liquidity tokens
    • On creation: Liquidation.amountRecovered
  • _defaultSufferedToPoolAndStake: in pool liquidity tokens
    • On creation: Liquidation.defaultSuffered
  • _amountReturnedToBorrower: in pool liquidity tokens
    • On creation: Liquidation.liquidationExcess

---

_Stake (immutable), extends Event: StakeLocker.sol→Stake (MplRewards.sol→Staked)

• Show data
  • market:
    • On creation:
      • stakeLockerAddress = event.transaction.to
      • stakeLocker = _StakeLocker(stakeLockerAddress)
      • marketAddress = stakeLocker.market
      • market = Market(marketAddress)
      • market.id
  • amount: in stakeToken
    • On creation: Stake.amount
  • asset:
    • On creation: stakeLocker.stakeToken
  • amountUSD
    • On creation: amount * stakeLocker.stakeTokenPriceUSD

---

_Unstake (immutable), extends Event: StakeLocker.sol→Unstake (MplRewards.sol→Withdrawn)

• Show data
  • market:
    • On creation:
      • stakeLockerAddress = event.transaction.to
      • stakeLocker = _StakeLocker(stakeLockerAddress)
      • marketAddress = stakeLocker.market
      • market = Market(marketAddress)
      • market.id
  • asset:
    • On creation: stakeLocker.stakeToken
  • amount:
    • On creation: Unstake.amount
  • amountUSD
    • On creation: amount * stakeLocker.stakeTokenPriceUSD

---

_PoolFactory: MapleGlobals.sol→setValidPoolFactory (call handler)

• Show data
  • id:
    • On creation: call.inputs.poolFactory
  • creationTimestamp:
    • On creation: call.block.timestamp
  • creationBlockNumber:
    • On creation: call.block.block_number
  • markets: derivedFrom(field: _poolFactoryAddress)

---

Market: PoolFactory.sol→PoolCreated

• Show data
  • id: Smart contract address of the market
    • On creation: PoolCreated.pool
  • protocol:
    • On creation: PROTOCOL_ID
  • _poolFactory:
    • On creation: PoolFactory(event.transaction.to)
  • _delegateAddress:
    • On creation: PoolCreated.delegate
  • name:
    • On creation: PoolCreated.name
  • isActive:
    • On creation: false
    • Update:
      • Pool.sol→PoolStateChanged: PoolStateChanged.state == State.Finalized
  • canUseAsCollateral:
    • On creation: false
  • canBorrowFrom:
    • On creation: false
    • Update:
      • Pool.sol→PoolStateChanged: PoolStateChanges.state == State.Finalized
  • maximumLTV: inapplicable, loan to loan basis
    • On creation: 0
  • liquidationThreshold: inapplicable, liquidation happens if borrower misses payments + grace period
    • On creation: 0
  • liquidationPenalty: no penalty, liquidation is done by pool delegate on missed payments
    • On creation: 0
  • inputToken: this is the liquidity token for the market (most are USDC)
    • On creation: PoolCreated.liquidityAsset
  • outputToken: LP token for the pool (pool address)
    • On creation: PoolCreated.pool
  • rates:
    • On creation: []
    • Update:
      • Pool.sol→LoanFunded:
        • Create new interest rate and append to list
          • InterestRate:
            • id: “BORROWER” + “FIXED_TERM” + Market.id
            • rate: loan.interestRate
            • duration: loan.termDays
            • maturityBlock: 0 (not applicable here)
            • side: BORROWER
            • _loan: LoanFunded.loan
  • inputTokenBalance: total amount input (not excluding amount being borrowed)
    • On creation: 0
    • Update: sum of all deposits - sum of all withdraws + sum of all interest earned to pool - sum of all defaults that hit the pool
      • Pool.sol→Claim: inputTokenBalance + Claim.interest
      • Pool.sol→DefaultSuffered: inputTokenBalance - (DefaultSuffered.defaultSuffered - DefaultSuffered.liquidityAssetRecoveredFromBurn)
      • Deposit: inputTokenBalance + Deposit.amount
      • Withdraw: inputTokenBalance - Withdraw.amount
      • Note:
        • this should equal: liquidityLockerBal + principalOut
        • this is NOT: inputToken.balanceOf(id), since this would account for loaned amounts
  • inputTokenPriceUSD:
    • On creation: MapleGlobals.getLatestPrice(inputToken)
    • Update:
      • anytime Market gets updated: MapleGlobals.getLatestPrice(inputToken)
  • outputTokenSupply:
    • On creation: 0
    • Update:
      • Deposit: outputTokenSupply + Deposit._amountMPT
      • Withdraw: outputTokenSupply - Withdraw._amountMPT
      • Note: should also equal Pool.totalSupply()
  • exchangeRate:
    • On creation: 0
    • Update:
      • anytime market updates: inputTokenBalance / outputTokenSupply
  • outputTokenPriceUSD:
    • On creation: 0
    • Update:
      • anytime Market gets updated: inputTokenPriceUSD / 10^inputToken.decimals * exchangeRate * 10^outputToken.decimals
  • createdTimestamp:
    • On creation: event.block.timestamp
  • CreationBlockNumber:
    • On creation: event.block.block_number
  • _stakeLocker:
    • On creation: PoolCreated.stakeLocker
  • totalValueLockedUSD: total amount on the supply side that is earning interest, it does not include accrued staking rewards since those aren’t controlled by protocol
    • On creation: 0
    • Update:
      • anytime Market gets updated: (inputTokenBalance + _stakeLocker.stakeTokenBalanceInPoolInputTokens) * inputTokenPriceUSD
  • totalDepositBalanceUSD: this does not include stake deposits (since these are not loanable)
    • On creation: 0
    • Update:
      • anytime Market gets updates: inputTokenBalance * inputTokenPriceUSD
  • _cumulativeDeposit: in liquidity asset, this does not include stake deposits (since these are not loanable)
    • On creation: 0
    • Update:
      • Deposit: _cumulativeDeposit + Deposit.amount
  • cumulativeDepositUSD: this does not include stake deposits (since these are not loanable)
    • On creation: 0
    • Update:
      • anytime Market gets updated: _cumulativeDeposit * inputTokenPriceUSD
  • _totalBorrowBalance: in liquidity asset, sum of all loans - sum of principal paid back - sum of amount recovered from liquidations - sum of excess not drawn down - sum of default suffered to pool or stakers
    • On creation: 0
    • Update:
      • Pool.sol→LoanFunded: _totalBorrowBalance + LoanFunded.amountFunded
      • Pool.sol→Claim: _totalBorrowBalance - Claim.principal
        • Claim.principal = loan principal paid + excess (amount not drawn down) + amountRecovered from liquidation
      • Pool.sol→DefaultSuffered: _totalBorrowBalance - DefaultSuffered.defaultSuffered
        • DefaultSuffered.defaultSuffered is total to pool and stakers
    • Note: this should equal Pool.sol->principalOut
  • _cumulativeBorrow: in liquidity asset
    • On creation: 0
    • Update:
      • Pool.sol→LoanFunded: _cumulativeBorrow + LoanFunded.amountFunded
  • totalBorrowBalanceUSD:
    • On creation: 0
    • Update:
      • anytime Market gets updated: _totalBorrowBalance * inputTokenPriceUSD
  • cumulativeBorrowUSD:
    • On creation: 0
    • Update:
      • anytime Market gets updated: _cumulativeBorrowBalance * inputTokenPriceUSD
  • _cumulativePoolDefault: in liquidity asset, amount of defaults that hit the pool
    • On creation: 0
    • Update:
      • Pool.sol→DefaultSuffered: _cumulativePoolDefault + (DefaultSuffered.defaultSuffered - DefaultSuffered.liquidityAssetRecoveredFromBurn)
      • Note: this should equal Pool.sol→poolLosses
  • _cumulativeCollatoralLiquidationInPoolInputTokens:
    • On creation: 0
    • Update: updated from _Loan (Loan.sol→Liquidation)
  • cumulativeLiquidateUSD: sum of all liquidated collateral + stake defaults + pool losses
    • On creation: 0
    • Update:
      • anytime Market gets updated: (_cumulativePoolDefault + _cumulativeCollatoralLiquidationInPoolInputTokens + _stakeLocker.cumulativeStakeDefaultInPoolInputTokens) * inputTokenPriceUSD
  • _poolDelegateRevenue: in liquidity asset, includes recurring fees and establishment fees
    • On creation: 0
    • Update:
      • Pool.sol→Claim: _poolDelegateRevenue + Claim.poolDelegatePortion
  • _poolDelegateRevenueUSD:
    • On creation: 0
    • Update:
      • anytime Market gets updated: _poolDelegateRevenue * inputTokenPriceUSD
  • _treasuryRevenue: in liquidity asset
    • On creation: 0
    • Update:
      • Loan.sol→Drawdown: _treasuryRevenue + (Drawdown.amt * Protocol._treasuryFee)
  • _treasuryRevenueUSD:
    • On creation: 0
    • Update:
      • anytime Market gets updated: _treasuryRevenue * inputTokenPriceUSD
  • _supplierRevenue: in liquidity asset
    • On creation: 0
    • Update
      • Pool.sol→Claim: _supplierSideRevenue + Claim.interest
  • _supplierRevenueUSD:
    • On creation: 0
    • Update:
      • anytime Market gets updated: _supplierRevenue * inputTokenPriceUSD
  • _supplySideRevenueUSD: this doesn’t include MPL token distrubution
    • On creation: 0
    • Update:
      • anytime Market gets updated: _supplierRevenueUSD + _stakeLocker.stakerRevenueUSD + _poolDelegateRevenueUSD
  • _protocolSideRevenueUSD:
    • On creation: 0
    • Update:
      • anytime Market gets updated: _treasuryRevenueUSD
  • _totalRevenueUSD:
    • On creation: 0
    • Update:
      • anytime Market gets updated: _protocolSideRevenueUSD + _supplySideRevenueUSD
  • _mplRewardsMplLp: MapleRewardsFactory.sol→MapleRewardsCreated
    • On creation: populated when the _MplRewards gets created
  • _mplRewardsMplStake: MapleRewardsFactory.sol→MapleRewardsCreated
    • On creation: populated when the _MplRewards gets created
  • rewardTokens:
    • On creation: []
    • Update:
      • MapleRewardsFactory.sol→MapleRewardsCreated:
        • if rewardTokens doesn’t contain MapleRewardsCreated.rewardsToken
          • rewardTokens.append(MapleRewardsCreated.rewardsToken)
  • rewardTokenEmissionsAmount:
    • On creation: []
    • Update:
      • anytime market gets updated:
        • for(i = 0; i < len(rewardTokens); i++):
          • tokenEmission = 0
          • rewardToken = rewardTokens[i]
          • if _mplRewardsMplLp.rewardToken == rewardToken.id:
            • tokenEmission += _mplRewardsMplLp.rewardTokenEmissionsAmountPerDay
          • if _mplRewardsMplStake.rewardToken == rewardToken.id:
            • tokenEmission += _mplRewardsMplLp.rewardTokenEmissionsAmountPerDay
          • rewardTokenEmissionsAmount[i] = tokenEmission
    • rewardTokenEmissionsUSD:
      • On creation: []
      • Update:
        • anytime market gets updated:
          • for(i = 0; i < len(rewardTokens); i++):
            • tokenEmission = 0
            • rewardToken = rewardTokens[i]
            • if _mplRewardsMplLp.rewardToken == rewardToken.id:
              • tokenEmission += _mplRewardsMplLp.rewardTokenEmissionsUSDPerDay
            • if _mplRewardsMplStake.rewardToken == rewardToken.id:
              • tokenEmission += _mplRewardsMplLp.rewardTokenEmissionsUSDPerDay
            • rewardTokenEmissionsUSD[i] = tokenEmission
    • _loans: derivedFrom(field: market)

---

_StakeLocker: PoolFactory.sol→PoolCreated

• Show data
  • id:
    • On creation: PoolCreated.stakeLocker
  • market:
    • On creation: PoolCreated.pool
  • stakeToken: currently USDC-MPL BPT for all pools
    • On creation: PoolCreated.stakeAsset
  • stakeTokenBalance: sum of all stake - sum of all unstake - sum of bpt burned to cover liquidations
    • On creation: 0
    • Update:
      • StakeLocker.sol→Stake: stakeTokenBalance + Stake.amount
      • StakeLocker.sol→Unstake: stakeTokenBalance - Unstake.amount
      • Pool.sol→DefaultSuffered: stakeTokenBalance - DefaultSuffered.bptsBurned
      • Note: should equal _stakeToken.balanceOf(_stakeLocker), and also DefaultSuffered.bptsReturned
  • stakeTokenBalanceInPoolInputTokens: value of stakeTokens if they were all swapped for pool input tokens (i.e amount available to cover defaults)
    • On creation: 0
    • Update:
      • anytime Market or StakeLocker gets updated:
        • poolLibAddress = Protocol._poolLib
        • poolLibContract = Contract(poolLibAddress)
        • poolLibContract.getSwapOutValueLocker(stakeToken, market.inputToken, id)
  • stakeTokenPriceUSD:
    • On creation: 0
    • Update: anytime Market or _StakeLocker gets updated
      • anytime Market or _StakeLocker gets updated: stakeTokenBalanceInPoolInputTokens * market.inputTokenPriceUSD / stakeTokenBalance
        • Need to be mindful of div by 0
  • cumulativeStakeDefault: amount in stake tokens lost to cover defaults
    • On creation: 0
    • Pool.sol→DefaultSuffered: cumulativeStakeDefault + DefaultSuffered.bptsBurned
  • cumulativeStakeDefaultInPoolInputTokens: amount in input tokens lost to cover defaults
    • On creation: 0
    • Update:
      • Pool.sol→DefaultSuffered: cumulativeStakeDefaultInPoolInputTokens + DefaultSuffered.liquidityAssetRecoveredFromBurn
  • revenueInPoolInputTokens: In pool liquidity asset
    • On creation: 0
    • Update
      • Pool.sol→Claim: revenueInPoolInputTokens + Claim.stakeLockerPortion
  • revenueUSD:
    • On creation: 0
    • Update:
      • anytime Market or _StakeLocker gets updated: revenueInPoolInputTokens * market.inputTokenPriceUSD
  • creationBlockNumber:
    • On creation: event.block.number
  • lastUpdatedBlock:
    • On creation: event.block.number
    • Update:
      • anytime stakeLocker is updated: event.block.number

---

_Loan: Pool.sol→LoanFunded

• Show data
  • id:
    • On creation: LoanFunded.loan
  • market:
    • On creation: event.transaction.to
  • amountFunded: in pool liquidity asset
    • On creation: LoanFunded.amountFunded
  • termDays:
    • On creation:
      • loanContract = Contract(loan.id)
      • loanContract.termDays
  • interestRate: Interest rate in percentage APY. E.g. 5.21% should be stored as 5.21
    • On creation:
      • loanContract = Contract(loan.id)
      • loanContract.apr / 100
  • drawnDown:
    • On creation: 0
    • Update:
      • Loan.sol→Drawdown: drawnDown + Drawdown.drawdownAmount
  • principalPaid: in pool liquidity asset
    • On creation: 0
    • Update:
      • Loan.sol→PaymentMade: principalPaid + PaymentMade.principalPaid
  • interestPaid: in pool liquidity asset
    • On creation: 0
    • Update:
      • Loan.sol→PaymentMade: interestPaid + interestPaid
  • collateralLiquidated: amount of pool liquidity assets recovered from liquidated collateral
    • On creation: 0
    • Update:
      • Loan.sol→Liquidation: collateralLiquidated + (Liquidation.liquidityAssetReturned - Liquidation.defaultSuffered)
        • market = Market(market)
        • market._cumulativeCollatoralLiquidationInPoolInputTokens += (Liquidation.liquidityAssetReturned - Liquidation.defaultSuffered)
  • defaultSuffered: default suffered to the pool in pool liquidity asset
    • On creation: 0
    • Update:
      • Loan.sol→Liquidation: defaultSuffered + Liquidation.defaultSuffered

---

_MplReward: MapleRewardsFactory.sol→MapleRewardsCreated

• Show data
  • id: Maple rewards contract address
    • On creation: MapleRewardsCreated.mplRewards
  • market:
    • On creation:
      • market = Market(MapleRewardsCreated.stakingToken)
      • if market == null: (i.e this is a stakeLocker)
        • stakeLocker = _StakeLocker(MapleRewardsCreated.stakingToken)
        • market = stakeLocker.market
        • market._mplRewardsMplStake = id
      • else:
        • market._mplRewardsMplLp = id
      • market.id
  • rewardToken: MPL generally
    • On creation: MapleRewardsCreated.rewardsToken
  • stakeToken:
    • On creation: MapleRewardsCreated.stakeToken
  • rewardRatePerSecond: total rewardToken distribution per second
    • On creation: 0
    • Update:
      • MplRewards.sol→RewardAdded: RewardAdded.rewards
  • rewardDurationSec: total rewardToken distribution for notifyRewardAmount will be rewardRate * rewardDuration
    • On creation: 604800 (7 days in seconds)
    • Update:
      • MplRewards.sol→RewardsDurationUpdated: RewardsDurationUpdated.newDuration
  • periodFinishedTimestamp:
    • On creation: 0
    • Update:
      • MplRewards.sol→RewardAdded: event.block.timestamp + rewardDurationSec
      • MplRewards.sol→updatePeriodFinish: updatePeriodFinish.timestamp
  • rewardTokenEmissionsAmountPerDay:
    • On creation: 0
    • Update:
      • anytime market or _MplRewards updates: event.block.timestamp > periodFinished ? 0 : rewardRate* rewardDurationSec * 86400
  • rewardTokenEmissionsUSDPerDay:
    • On creation: 0
    • Update:
      • anytime market or _MplRewards updates: TODO: get price from an oracle, MapleGlobals.getLatestPrice(rewardToken doesn’t necessarily work)

---

LendingProtocol:

• Show data
  • id: MapleGlobals address
    • On creation: 0xC234c62c8C09687DFf0d9047e40042cd166F3600
  • name:
    • On creation: “Maple v1”
  • slug:
    • On creation: “maple-v1”
  • schemaVersion:
    • On creation: “1.2.1”
  • subgraphVersion:
    • On creation: "1.0.0”
  • methodologyVersion:
    • On creation: 1.0.0"
  • network:
    • On creation: MAINNET
  • type:
    • On creation: LENDING
  • lendingType:
    • On creation: POOLED
  • RiskType:
    • On creation: ISOLATED
  • _treasuryFee: % fee on drawdown amount that goes to treasury (establishment fee to treasury)
    • On creation: 50 (i.e 0.5%)
    • Update:
      • MapleGlobals.sol→GlobalsParamSet:
        • filter on GlobalsParamSet.which == “TREASURY_FEE”
          • GlobalsParamSet.value
  • cumulativeUniqueUsers
    • On creation: 0
    • Update
      • any transaction: → TODO: Arslanbek to implement
        • accountAddress = event.transaction.from
        • account = Account(accountAddress)
        • if account didn’t exist
          • create Account
          • cumulativeUniqueUsers + 1
  • totalValueLockedUSD:
    • On creation: 0
    • Update:
      • anytime a market updates: totalValueLockedUSD + (market.totalValueLockedUSD_after_update - market.totalValueLockedUSD_before_update)
  • totalDepositBalanceUSD:
    • On creation: 0
    • Update:
      • anytime a market updates: totalDepositBalanceUSD + (market.totalDepositBalanceUSD_after_update - market.totalDepositBalanceUSD_before_update)
  • cumulativeDepositUSD:
    • On creation: 0
    • Update:
      • anytime a market updates: cumulativeDepositUSD + (market.cumulativeDepositUSD_after_update - market.cumulativeDepositUSD_before_update)
  • totalBorrowBalanceUSD:
    • On creation: 0
    • Update:
      • anytime a market updates: totalBorrowBalanceUSD + (market.totalBorrowBalanceUSD_after_update - market.totalBorrowBalanceUSD_before_update)
  • cumulativeBorrowUSD
    • On creation: 0
    • Update:
      • anytime a market updates: cumulativeBorrowUSD + (market.cumulativeBorrowUSD_after_update - market.cumulativeBorrowUSD_before_update)
  • cumulativeLiquidateUSD
    • On creation: 0
    • Update:
      • anytime a market updates: cumulativeLiquidateUSD + (market.cumulativeLiquidateUSD_after_update - market.cumulativeLiquidateUSD_before_update)
  • cumulativeSupplySideRevenueUSD:
    • On creation: 0
    • Update:
      • anytime a market updates: cumulativeSupplySideRevenueUSD + (market._cumulativeSupplySideRevenueUSD_after_update - market._cumulativeSupplySideRevenueUSD_before_update)
  • cumulativeProtocolSideRevenueUSD:
    • On creation: 0
    • Update:
      • anytime a market updates: cumulativeProtocolSideRevenueUSD + (market._treasuryRevenueUSD_after_update - market._treasuryRevenueUSD_before_update)
  • cumulativeTotalRevenueUSD:
    • On creation: 0
    • Update:
      • anytime a market updates: cumulativeTotalRevenueUSD + (market.cumulativeTotalRevenueUSD_after_update - market.cumulativeTotalRevenueUSD_before_update)
  • mintedTokens: unused, don’t apply to Maple (CDPs only)
    • On creation: []
  • mintedTokenSupplies: unused, don’t apply to Maple (CDPs only)
    • On creation: []
  • protocolControlledValueUSD:
    • On creation: 0
    • Update:
      • TODO: Messari didn’t provide a clear answer about this, waiting for response in Discord