Fund

Getting Fund Info

Fund.tokenUnderlying() → address

The address of the underlying asset.

>>> fund.tokenUnderlying()
'0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'

Fund.tokenShare(uint256 tranche) → address

Getter for one of the addresses of tranche: QUEEN (0), BISHOP (1) or ROOK (2).

>>> fund.tokenShare(0)
'0x93ef1Ea305D11A9b2a3EbB9bB4FCc34695292E7d'

Fund.primaryMarket() → address

The address of the primary market contract.

>>> fund.primaryMarket()
'0xcD0B4D35cc6Ec86d1D52b8Eb07b5d029e39bA70E'

Fund.primaryMarketUpdateProposal() → address, uint256

Getter for the upcoming primary market upgrade, if any.

Fund.twapOracle() → ITwapOracleV2

The TWAP Oracle of the underlying asset.

>>> fund.twapOracle()
'0x2BaC57D29570Fe56B60216c26dA3C5B5c804B916'

Fund.feeCollector() → address

The address of the fee collector of the fund.

>>> fund.feeCollector()
'0xbc428f6573827Db9773F9e4bC1f5C899c884842c'

Fund.endOfDay(uint256 timestamp) → uint256

It calculates the trading day end timestamp of the given timestamp. A trading day starts at UTC time SETTLEMENT_TIME of a day (inclusive) and ends at the same time of the next day (exclusive).

>>> fund.endOfDay(1604214000)
'1604239200'

Fund.trancheTotalSupply(uint256 tranche) → uint256

Getter for the total supply of tranche.

>>> fund.trancheTotalSupply(0)
'144207156642170957094'

Fund.getRebalanceSize() → uint256

Getter for the number of historical rebalances.

>>> fund.getRebalanceSize()
'1'

Fund.getRebalance(uint256 index) → Rebalance

Getter for the Rebalance parameters of a given rebalance version.

>>> fund.getRebalance(0)
ratioB2Q: '442549502169234'
ratioR2Q: '0'
ratioBR: '474988241234265736'
timestamp: '1668702923'

Fund.currentDay() → uint256

The end timestamp of the current trading day.

>>> fund.currentDay()
'1670248800'

Fund.splitRatio() → uint256

The amount of BISHOP received by splitting one QUEEN. This ratio changes on every rebalance.

>>> fund.splitRatio()
'594418130555555555274'

Fund.historicalSplitRatio(uint256 version) → uint256

Getter for past split ratio of a given rebalance version.

>>> fund.historicalSplitRatio(0)
'805392577500508333333'

Fund.fundActivityStartTime() → uint256

Getter for the start timestamp of the current activity window of the fund.

>>> fund.fundActivityStartTime()
'1670162400'

Fund.isFundActive(uint256 timestamp) → bool

Check if the fund is currently active.

Fund.getEquivalentTotalB() → uint256

Getter for the equivalent amount of BISHOP supply if all QUEEN are split.

>>> fund.getEquivalentTotalB()
'85719348463971426438951'

Fund.getEquivalentTotalQ() → uint256

Getter for the equivalent amount of QUEEN supply if all BISHOP and ROOK are merged.

>>> fund.getEquivalentTotalQ()
'144207156642170957094'

Fund.historicalEquivalentTotalB(uint256 day) → uint256

Getter for the past equivalent total amount of BISHOP on a given day.

>>> fund.historicalEquivalentTotalB(1669903200)
'85717176424199353954085'

Fund.historicalNavs(uint256 day) → uint256, uint256

Getter for the past net asset values on a given day.

>>> fund.historicalNavs(1669903200)
navB: '1002161928302678888'
navR: '1159606682688588925'

Fund.extrapolateNav(uint256 price) → uint256

It estimates the current net asset values of all tranches, considering the current underlying price, the accrued protocol fee and interest since the previous settlement.

Fund.historicalUnderlying(uint256 day) → uint256

Getter for the past underlying amount on a given day.

>>> fund.historicalUnderlying(1669903200)
'144402940283113283926'

Fund.getTotalUnderlying() → uint256

Getter for the current total underlying amount.

>>> fund.getTotalUnderlying()
'144439536988113283926'

Fund.getStrategyUnderlying() → uint256

Getter for the current total underlying amount in strategy contract.

>>> fund.historicalUnderlying()
'128181515724000000000'

Fund.getTotalDebt() → uint256

Getter for the amount of underlying that the fund owes the primary market for redemption.

>>> fund.getTotalDebt()
'0'

Handling Rebalances

Fund.doRebalance(uint256 amountQ, uint256 amountB, uint256 amountR, uint256 index) → uint256, uint256, uint256

Get the results of share amounts amountQ, amountB, amountR after performing the rebalance at index.

• Note that this function performs no bounds checking on the given index; the transformation of a non-existent rebalance will result in undefined behavior.

>>> fund.doRebalance(1000000000000000000, 1000000000000000000, 1000000000000000000, 0)
newAmountQ: '1000442549502169234'
newAmountB: '474988241234265736'
newAmountR: '474988241234265736'

Fund.batchRebalance(uint256 amountQ, uint256 amountB, uint256 amountR, uint256 fromIndex, uint256 toIndex) → uint256, uint256, uint256

Get the results of share amounts amountQ, amountB, amountR after performing the rebalances from fromIndex to toIndex.

• Note that this function performs no bounds checking on the given indices. The original amounts are returned if fromIndex is no less than toIndex. A zero vector is returned if toIndex is greater than the number of existing rebalances.

Fund.refreshBalance(address account, uint256 targetVersion)

Transform share balances of accountto a given targetVersion.

• Note that setting targetVersion to zero transforms the share balances to the latest version.

Fund.refreshAllowance(address owner, address spender, uint256 targetVersion)

Transform share allowances of spender approved by owner to a given targetVersion.

• Note that setting targetVersion to zero transforms the share allowances to the latest version.

Transferring Tranche Tokens

Fund.trancheBalanceOf(uint256 tranch, address account) → uint256

Get the balance of tranche for the account.

Fund.trancheAllBalanceOf(address account) → uint256, uint256, uint256

Get the balances of all tranches for the account.

Fund.trancheBalanceVersion(address account) → uint256

Get the last rebalance version for the account.

Fund.trancheAllowance(uint256 tranch, address owner, address spender) → uint256

Get the allowance approved to spender of tranche by the owner.

Fund.trancheAllowanceVersion(address owner, address spender) → uint256

Get the last rebalance version of spender's allowance by the owner.

Fund.trancheTransfer(uint256 tranche, address recipient, uint256 amount, uint256 version)

Refresh the balances of msg.sender and recipient, then transfer amount of tranche from msg.sender to recipient. It enforces the version to be the current rebalance version.

Fund.trancheTransferFrom(uint256 tranche, address sender, address recipient, uint256 amount, uint256 version)

Refresh the balances of sender and recipient and the allowances of msg.sender approved by sender, then transfer amount of tranche from sender to recipient. It enforces the version to be the current rebalance version.

Fund.trancheApprove(uint256 tranche, address spender, uint256 amount, uint256 version)

Sets amount as the allowance of spender over tranche. It enforces the version to be the current rebalance version.