# Fund

## Getting Fund Info

#### `Fund.tokenUnderlying() → address`

The address of the underlying asset.

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

#### `Fund.tokenShare(uint256 tranche) → address`

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

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

#### `Fund.primaryMarket() → address`

The address of the primary market contract.

```bash
>>> 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.

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

#### `Fund.feeCollector() → address`

The address of the fee collector of the fund.

```bash
>>> 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).

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

#### `Fund.trancheTotalSupply(uint256 tranche) → uint256`

Getter for the total supply of `tranche`.

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

#### `Fund.getRebalanceSize() → uint256`

Getter for the number of historical rebalances.

```bash
>>> fund.getRebalanceSize()
'1'
```

#### `Fund.getRebalance(uint256 index) → Rebalance`

Getter for the Rebalance parameters of a given rebalance version.

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

#### `Fund.currentDay() → uint256`

The end timestamp of the current trading day.

```bash
>>> fund.currentDay()
'1670248800'
```

#### `Fund.splitRatio() → uint256`

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

```bash
>>> fund.splitRatio()
'594418130555555555274'
```

#### `Fund.historicalSplitRatio(uint256 version) → uint256`

Getter for past split ratio of a given rebalance version.

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

#### `Fund.fundActivityStartTime() → uint256`

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

```bash
>>> 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.

```bash
>>> fund.getEquivalentTotalB()
'85719348463971426438951'
```

#### `Fund.getEquivalentTotalQ() → uint256`

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

```bash
>>> fund.getEquivalentTotalQ()
'144207156642170957094'
```

#### `Fund.historicalEquivalentTotalB(uint256 day) → uint256`

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

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

#### `Fund.historicalNavs(uint256 day) → uint256, uint256`

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

```bash
>>> 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`.

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

#### `Fund.getTotalUnderlying() → uint256`

Getter for the current total underlying amount.

```bash
>>> fund.getTotalUnderlying()
'144439536988113283926'
```

#### `Fund.getStrategyUnderlying() → uint256`

Getter for the current total underlying amount in strategy contract.

```bash
>>> fund.historicalUnderlying()
'128181515724000000000'
```

#### `Fund.getTotalDebt() → uint256`

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

```shell
>>> 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.

```bash
>>> 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 `account`to 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.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.tranchess.com/tech-support/protocol-overview/fund.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.