YieldBasis

https://docs.yieldbasis.com/
Admin
YieldBasis is a decentralized finance platform that provides yield generation and asset management...
Tokens:35,320
Snippets:181
Trust Score:7.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Get Expected Output from Virtual Pool

Source: https://docs.yieldbasis.com/dev/arbitrage

Calculates the expected output amount for a given input amount in the Virtual Pool. This is useful for estimating trade outcomes before execution. The function takes input and output asset indices (0 for stablecoin, 1 for asset) and the input amount.

```solidity
# Returns expected output in either stablecoin or asset
# i=0: stablecoin, i=1: asset
expected_output = VirtualPool.get_dy(i, j, in_amount)
```

--------------------------------

### Renounce Ownership and Start Emissions (Vyper)

Source: https://docs.yieldbasis.com/dev/yb

External Vyper function that allows the owner to renounce ownership of the contract. It also forces the emission process to start if it hasn't already and removes the renouncing address from the list of minters, emitting a `RoleMinterChanged` event.

```vyper
@external  
def renounce_ownership():  
    ownable._check_owner()  
    # Force-start emissions when renouncing ownership  
    if self.last_minted == 0:  
        self.last_minted = block.timestamp  
    erc20.is_minter[msg.sender] = False  
    log erc20.RoleMinterChanged(minter=msg.sender, status=False)  
    ownable._transfer_ownership(empty(address))  

```

--------------------------------

### GET /preview_claim

Source: https://docs.yieldbasis.com/dev/liquidity-gauge

Previews the amount of rewards a user can claim without executing the claim transaction. Useful for checking potential earnings.

```APIDOC
## GET /preview_claim

### Description
Preview the amount of rewards a user can claim without executing the claim.

### Method
GET

### Endpoint
/preview_claim

### Parameters
#### Query Parameters
- **reward** (IERC20) - Required - Reward token to preview
- **user** (address) - Required - User to preview for

### Request Example
```bash
GET /preview_claim?reward=0xYourRewardTokenAddress&user=0x1234567890abcdef1234567890abcdef12345678
```

### Response
#### Success Response (200)
- **claimable_rewards** (uint256) - Preview of claimable rewards.

#### Response Example
```json
{
  "claimable_rewards": "75000000000000000"
}
```
```

--------------------------------

### Execute Arbitrage (BTC -> crvUSD)

Source: https://docs.yieldbasis.com/dev/arbitrage

Initiates the arbitrage process when the price of BTC is expected to increase, converting BTC to crvUSD. The VirtualPool handles the internal steps including borrowing, minting LP tokens, trading, and repaying.

```python
# Input: BTC to Virtual Pool via VirtualPool.exchange()
# The following steps are handled internally by VirtualPool:
# 1. Flash borrow stablecoin from Factory.flash()
# 2. Mint LP tokens using POOL.add_liquidity()
# 3. Sell LP tokens for stablecoin via AMM.exchange()
# 4. Repay flash loan from the stablecoin side
# 5. Output remaining stablecoin (crvUSD) to the arbitrageur
VirtualPool.exchange(1, 0, asset_in, min_out)
```

--------------------------------

### Calculate Expected Output Tokens with VirtualPool.get_dy()

Source: https://docs.yieldbasis.com/dev/arbitrage

This snippet demonstrates how to use the `VirtualPool.get_dy()` function to calculate the expected output tokens for a given input amount and swap direction. It highlights the parameters for specifying the input and output token types (crvUSD to BTC or BTC to crvUSD).

```python
# i=0: crvUSD -> BTC, i=1: BTC -> crvUSD
out = VirtualPool.get_dy(i, j, in_amount)
```

```python
# Check expected crvUSD output for BTC input
expected_crvusd = VirtualPool.get_dy(1, 0, 0.1 * 10**8)  # BTC -> crvUSD
```

--------------------------------

### Calculate Expected Profit (Price Increase Arbitrage)

Source: https://docs.yieldbasis.com/dev/arbitrage

Calculates the potential profit for a price increase arbitrage scenario. It involves determining the expected output amount from the VirtualPool for a given BTC input and comparing it against the market price.

```python
# Calculate expected output from Virtual Pool  
expected_output = VirtualPool.get_dy(1, 0, btc_amount)  
profit = expected_output - btc_amount * market_price
```

--------------------------------

### Calculate Expected Profit (Price Decrease Arbitrage)

Source: https://docs.yieldbasis.com/dev/arbitrage

Calculates the potential profit for a price decrease arbitrage scenario. It involves determining the expected output amount from the VirtualPool for a given stablecoin input and comparing it against the market price.

```python
# Calculate expected output from Virtual Pool  
expected_output = VirtualPool.get_dy(0, 1, stablecoin_amount)  
profit = expected_output - stablecoin_amount / market_price
```

--------------------------------

### Start Token Emissions (Vyper)

Source: https://docs.yieldbasis.com/dev/yb

External Vyper function to initiate the token emission process by setting the `last_minted` timestamp. This function is restricted to the contract owner and ensures emissions only begin once.

```vyper
@external  
def start_emissions():  
    ownable._check_owner()  
    if self.last_minted == 0:  
        self.last_minted = block.timestamp  

```

--------------------------------

### GET /get_dy

Source: https://docs.yieldbasis.com/dev/levamm

Calculates the expected output amount for a given input amount when swapping between stablecoins and LP tokens. This is a view function that applies fees and slippage calculations without executing the actual swap.

```APIDOC
## GET /get_dy

### Description
Calculates the expected output amount for a given input amount when swapping between stablecoins and LP tokens. This is a view function that applies fees and slippage calculations without executing the actual swap.

### Method
GET

### Endpoint
/get_dy

### Parameters
#### Path Parameters
None

#### Query Parameters
- **i** (uint256) - Required - Input token index (0=stablecoin, 1=LP token)
- **j** (uint256) - Required - Output token index (must be opposite of i)
- **in_amount** (uint256) - Required - Amount of input tokens to swap

### Request Example
```json
{
  "i": 0,
  "j": 1,
  "in_amount": "1000000000000000000"
}
```

### Response
#### Success Response (200)
- **expected_output_amount** (uint256) - The expected output amount for the given input, accounting for fees and slippage.

#### Response Example
```json
{
  "expected_output_amount": "980000000000000000"
}
```
```

--------------------------------

### Get AMM State

Source: https://docs.yieldbasis.com/dev/arbitrage

Retrieves the current state of the Automated Market Maker (AMM). The state includes the collateral amount (LP token amount), accrued debt, and a virtual balance for 2x leverage. This information is crucial for understanding the AMM's financial standing and leverage ratios.

```solidity
# Returns (collateral, debt, x0)
state = AMM.get_state()
collateral = state[0]  # LP token amount
debt = state[1]        # Interest-accrued debt
x0 = state[2]          # Virtual balance for 2x leverage
```

--------------------------------

### Get Token Addresses from Virtual Pool

Source: https://docs.yieldbasis.com/dev/arbitrage

Retrieves the contract addresses for the stablecoin and asset tokens managed by the Virtual Pool. This function is essential for interacting with the tokens in other smart contracts or external applications. It uses indices 0 for the stablecoin and 1 for the asset.

```solidity
# Get token addresses
stablecoin = VirtualPool.coins(0)  # crvUSD address
asset = VirtualPool.coins(1)      # BTC address
```

--------------------------------

### GET /get_debt

Source: https://docs.yieldbasis.com/dev/levamm

Fetches the current debt amount, which includes any interest that has accumulated over time. This is crucial for accurate financial calculations.

```APIDOC
## GET /get_debt

### Description
Returns the current debt including accumulated interest. This function accounts for the time-based interest accrual since the last rate update.

### Method
GET

### Endpoint
/get_debt

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **debt** (uint256) - The current debt amount including accumulated interest.

#### Response Example
```json
{
  "debt": "512345678900000000"
}
```
```

--------------------------------

### GET /preview_deposit

Source: https://docs.yieldbasis.com/dev/lt

Returns the amount of shares that would be obtained by depositing assets, simulating the transaction without executing it and including potential slippage.

```APIDOC
## GET /preview_deposit

### Description
Returns the amount of shares which can be obtained upon depositing assets, including slippage. This is a view function that simulates the deposit without executing it.

### Method
GET

### Endpoint
/websites/yieldbasis/preview_deposit

### Parameters
#### Path Parameters
None

#### Query Parameters
- **assets** (uint256) - Required - Amount of crypto to deposit
- **debt** (uint256) - Required - Amount of stables to borrow for MMing (approx same value as crypto)

### Request Example
```json
{
  "assets": "1000000000000000000",
  "debt": "1000000000000000000"
}
```

### Response
#### Success Response (200)
- **uint256** - Amount of shares that would be minted for the given assets and debt.

#### Response Example
```json
{
  "shares_minted": "995000000000000000"
}
```
```

--------------------------------

### Check Expected BTC Output (crvUSD input)

Source: https://docs.yieldbasis.com/dev/arbitrage

Calculates the expected amount of BTC received when inputting a specified amount of crvUSD into the VirtualPool. This function abstracts the complex internal arbitrage process, including LP trades and flash loans.

```python
expected_btc = VirtualPool.get_dy(0, 1, 10_000 * 10**18)  # crvUSD -> BTC
```

--------------------------------

### Exchange Assets in Virtual Pool

Source: https://docs.yieldbasis.com/dev/arbitrage

Executes an exchange operation within the Virtual Pool. This function is used for trading assets, such as converting BTC to stablecoins or vice versa. It requires specifying the input and output indices, the amount to exchange, and a minimum acceptable output amount to prevent slippage.

```solidity
VirtualPool.exchange(1, 0, btc_amount, min_out_amount)
```

```solidity
VirtualPool.exchange(0, 1, stablecoin_amount, min_out_amount)
```

--------------------------------

### AMM Exchange Function for State Updates

Source: https://docs.yieldbasis.com/dev/arbitrage

Demonstrates how the AMM's exchange function updates internal state (collateral and debt) after a trade. It includes an assertion to ensure the trade does not violate safety bounds, enforcing a return to the safe region around 2x leverage.

```vyper
assert self.get_x0(p_o, collateral_after, debt_after, True) >= x0_before, "Bad final state"
```

--------------------------------

### GET /get_state

Source: https://docs.yieldbasis.com/dev/levamm

Retrieves the current state of the Automated Market Maker (AMM), including collateral, debt, and equilibrium point. This is essential for understanding the AMM's financial standing.

```APIDOC
## GET /get_state

### Description
Returns the current AMM state including collateral, debt, and equilibrium point. This function provides a snapshot of the AMM's current position and is used by other contracts to understand the system state.

### Method
GET

### Endpoint
/get_state

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **collateral** (uint256) - The amount of collateral in the AMM.
- **debt** (uint256) - The amount of debt in the AMM, including accumulated interest.
- **x0** (uint256) - The equilibrium point of the AMM.

#### Response Example
```json
{
  "collateral": "1000000000000000000",
  "debt": "500000000000000000",
  "x0": "750000000000000000"
}
```
```

--------------------------------

### Get AMM Price Function (`get_p`) in Vyper

Source: https://docs.yieldbasis.com/dev/levamm

The `get_p` function, marked as a view function, retrieves the current price of LP tokens in stablecoins from the AMM. It queries the `PRICE_ORACLE_CONTRACT` for its price and uses internal calculations involving collateral and debt to determine the exchange rate.

```vyper
@external
@view
def get_p() -> uint256:
    p_o: uint256 = staticcall PRICE_ORACLE_CONTRACT.price()
    collateral: uint256 = self.collateral_amount
    debt: uint256 = self._debt()
    return (self.get_x0(p_o, collateral, debt, False) - debt) * (10**18 // COLLATERAL_PRECISION) // collateral

```

--------------------------------

### Calculate Current DTV Ratio (Python)

Source: https://docs.yieldbasis.com/dev/arbitrage

Calculates the Debt-to-Value (DTV) ratio for the AMM using the current state and an external price oracle. This ratio indicates the proportion of debt relative to the value of the collateral, which is a key metric for assessing risk and leverage. Ensure price precision scaling is handled appropriately.

```python
def calculate_dtv_ratio():
    state = AMM.get_state()                 # collateral (LP), debt, x0
    p_o = PRICE_ORACLE_CONTRACT.price()     # oracle price
    # Include the same precision scaling you use elsewhere if needed
    collateral_value = p_o * state.collateral
    dtv = state.debt * 10**18 // collateral_value
    return dtv  # ~5e17 (50%) at target
```

--------------------------------

### Get Maximum Borrowable Debt (Solidity)

Source: https://docs.yieldbasis.com/dev/levamm

Calculates the maximum amount of debt that can be borrowed. This is determined by summing the current stablecoin balance and the existing debt. The function returns a uint256 representing the maximum borrowable debt.

```Solidity
@external
@view
def max_debt() -> uint256:
    return staticcall STABLECOIN.balanceOf(self) + self._debt()

```

--------------------------------

### AMM Leverage Calculation Function

Source: https://docs.yieldbasis.com/dev/arbitrage

This function calculates the virtual balance (x0) required to maintain a 2x leverage ratio in the AMM. It takes the oracle price, current collateral, and debt as inputs, and can optionally enforce safety limits.

```vyper
def get_x0(p_o: uint256, collateral: uint256, debt: uint256, safe_limits: bool) -> uint256:
    # x0 represents the virtual balance maintaining 2x leverage
    # p_o = oracle price
    # collateral = LP token amount (the AMM's collateral)
    # debt = stablecoin debt (interest-accrued where applicable)
    # safe_limits = enforce safety band when True

```

--------------------------------

### Get Token Addresses (Solidity)

Source: https://docs.yieldbasis.com/dev/levamm

Returns the contract address for a specified token. Index 0 returns the stablecoin address, and index 1 returns the LP token address. The function takes a uint256 index as input and returns an IERC20 contract interface.

```Solidity
@external
@view
def coins(i: uint256) -> IERC20:
    return [STABLECOIN, COLLATERAL][i]

```

--------------------------------

### Solidity: VirtualPool _calculate Function for AMM State

Source: https://docs.yieldbasis.com/dev/arbitrage

This Solidity code snippet implements the `_calculate` internal view function within the VirtualPool contract. It calculates the output amount and flash loan amount based on the AMM's state, pool balances, supply, and fees. This function is crucial for determining the profitability of arbitrage trades by simulating swap outcomes without direct LP custody.

```solidity
@internal
@view
def _calculate(i: uint256, in_amount: uint256, only_flash: bool) -> (uint256, uint256):
    stables_in_pool: uint256 = staticcall POOL.balances(0)
    out_amount: uint256 = 0

    if i == 0:
        state: AMMState = staticcall AMM.get_state()
        pool_supply: uint256 = staticcall POOL.totalSupply()
        fee: uint256 = staticcall AMM.fee()
        r0fee: uint256 = stables_in_pool * (10**18 - fee) // pool_supply

        # Solving quadratic eqn instead of calling the AMM b/c we have a special case
        b: uint256 = state.x0 - state.debt + in_amount - r0fee * state.collateral // 10**18
        D: uint256 = b**2 + 4 * state.collateral * r0fee // 10**18 * in_amount
        flash_amount: uint256 = (isqrt(D) - b) // 2  # We received this withdrawing from the pool

        if not only_flash:
            crypto_in_pool: uint256 = staticcall POOL.balances(1)
            out_amount = flash_amount * crypto_in_pool // stables_in_pool
        # Withdrawal was ideally balanced
        return out_amount, flash_amount

    else:
        crypto_in_pool: uint256 = staticcall POOL.balances(1)
        flash_amount: uint256 = in_amount * stables_in_pool // crypto_in_pool
        if not only_flash:
            pool_supply: uint256 = staticcall POOL.totalSupply()
            lp_amount: uint256 = pool_supply * in_amount // crypto_in_pool
            out_amount = staticcall AMM.get_dy(1, 0, lp_amount) - flash_amount
        return out_amount, flash_amount
```

--------------------------------

### Add Market to Yield Basis Protocol

Source: https://docs.yieldbasis.com/dev/factory

Creates a new market for a crypto asset by deploying necessary contracts like price oracle, LT, AMM, virtual pool, and staker. This function requires admin privileges and validates inputs such as the stablecoin and decimals. It returns the newly created market struct and emits a MarketParameters event.

```Vyper
@external
@nonreentrant
def add_market(
    pool: CurveCryptoPool,
    fee: uint256,
    rate: uint256,
    debt_ceiling: uint256
) -> Market:
    assert msg.sender == self.admin, "Access"
    assert staticcall pool.coins(0) == STABLECOIN.address, "Wrong stablecoin"
    assert staticcall pool.decimals() == 18

    market: Market = empty(Market)
    agg: address = self.agg

    market.asset_token = IERC20(staticcall pool.coins(1))
    market.cryptopool = pool
    market.price_oracle = create_from_blueprint(self.price_oracle_impl, pool.address, agg)
    market.lt = create_from_blueprint(
        self.lt_impl,
        market.asset_token.address,
        STABLECOIN,
        pool.address,
        self
    )
    market.amm = create_from_blueprint(
        self.amm_impl,
        market.lt,
        STABLECOIN.address,
        pool.address,
        LEVERAGE,
        fee,
        market.price_oracle
    )
    extcall LT(market.lt).set_amm(market.amm)
    extcall LT(market.lt).set_rate(rate)
    assert extcall STABLECOIN.approve(market.lt, max_value(uint256), default_return_value=True)
    extcall LT(market.lt).allocate_stablecoins(debt_ceiling)

    if self.virtual_pool_impl != empty(address) and self.flash != empty(address):
        market.virtual_pool = create_from_blueprint(
            self.virtual_pool_impl,
            market.amm
        )
    if self.staker_impl != empty(address):
        market.staker = create_from_blueprint(
            self.staker_impl,
            market.lt)
        extcall LT(market.lt).set_staker(market.staker)

    i: uint256 = self.market_count
    assert i < MAX_MARKETS, "Too many markets"
    self.market_count = i + 1
    self.markets[i] = market

    log MarketParameters(
        idx=i,
        asset_token=market.asset_token.address,
        cryptopool=market.cryptopool.address,
        amm=market.amm,
        lt=market.lt,
        price_oracle=market.price_oracle,
        virtual_pool=market.virtual_pool,
        staker=market.staker,
        agg=agg
    )

    return market

```

--------------------------------

### preview_emissions()

Source: https://docs.yieldbasis.com/dev/gauge-controller

Preview the emissions a gauge would receive at a specific time without causing state changes.

```APIDOC
## preview_emissions()

### Description
Preview the emissions a gauge would receive at a specific time without causing state changes.

### Method
VIEW

### Endpoint
/preview_emissions

### Parameters
#### Query Parameters
- **gauge** (address) - Required - Gauge address
- **at_time** (uint256) - Required - Timestamp to preview emissions at

### Response
#### Success Response (200)
- **return_value** (uint256) - Preview of emissions for the gauge.

### Response Example
```json
{
  "return_value": "1000000000000000000"
}
```
```

--------------------------------

### Implement Flash Loan Swap Logic (Vyper)

Source: https://docs.yieldbasis.com/dev/virtual-pool

This Vyper code defines the `onFlashLoan` callback function. It handles the execution of token swaps after receiving a flash loan, including logic for both stablecoin-to-crypto and crypto-to-stablecoin exchanges. It requires external calls to AMM and Pool contracts for liquidity management and exchanges. The function ensures proper repayment of the flash loan and transfer of the remaining assets.

```Vyper
interface Pool:
    def approve(_spender: address, _value: uint256) -> bool: nonpayable
    def coins(i: uint256) -> ERC20: view
    def balances(i: uint256) -> uint256: view
    def calc_token_amount(amounts: uint256[2], deposit: bool) -> uint256: view
    def add_liquidity(amounts: uint256[2], min_mint_amount: uint256) -> uint256: nonpayable
    def remove_liquidity(amount: uint256, min_amounts: uint256[2]) -> uint256[2]: nonpayable
    def totalSupply() -> uint256: view

interface YbAMM:
    def coins(i: uint256) -> ERC20: view
    def get_dy(i: uint256, j: uint256, in_amount: uint256) -> uint256: view
    def get_state() -> AMMState: view
    def fee() -> uint256: view
    def exchange(i: uint256, j: uint256, in_amount: uint256, min_out: uint256) -> uint256: nonpayable
    def STABLECOIN() -> ERC20: view
    def COLLATERAL() -> Pool: view

FACTORY: public(immutable(Factory))
AMM: public(immutable(YbAMM))
POOL: public(immutable(Pool))
ASSET_TOKEN: public(immutable(ERC20))
STABLECOIN: public(immutable(ERC20))
ROUNDING_DISCOUNT: public(constant(uint256)) = 10**18 // 10**8
IMPL: public(immutable(address))

@external
def onFlashLoan(initiator: address, token: address, total_flash_amount: uint256, fee: uint256, data: Bytes[10**5]):
    assert initiator == self
    assert token == STABLECOIN.address
    assert msg.sender == (staticcall FACTORY.flash()).address, "Wrong caller"

    # executor
    i: uint256 = 0
    in_amount: uint256 = 0
    i, in_amount = abi_decode(data, (uint256, uint256))
    flash_amount: uint256 = self._calculate(i, in_amount, True)[1]
    in_coin: ERC20 = [STABLECOIN, ASSET_TOKEN][i]
    out_coin: ERC20 = [STABLECOIN, ASSET_TOKEN][1-i]
    repay_flash_amount: uint256 = total_flash_amount

    if i == 0:
        # stablecoin -> crypto exchange
        # 1. Take flash loan
        # 2. Use our stables + flash borrowed amount to swap to pool LP in AMM
        # 3. Withdraw symmetrically from pool LP
        # 4. Repay the flash loan
        # 5. Send the crypto
        lp_amount: uint256 = extcall AMM.exchange(0, 1, (in_amount * (10**18 - ROUNDING_DISCOUNT) // 10**18 + flash_amount), 0)
        extcall POOL.remove_liquidity(lp_amount, [0, 0])
        repay_flash_amount = staticcall STABLECOIN.balanceOf(self)

    else:
        # crypto -> stablecoin exchange
        # 1. Take flash loan
        # 2. Deposit taken stables + to Pool
        # 3. Swap LP of the pool to stables
        # 4. Repay flash loan
        # 5. Send the rest to the user
        lp_amount: uint256 = extcall POOL.add_liquidity([flash_amount, in_amount], 0)
        extcall AMM.exchange(1, 0, lp_amount, 0)

    assert extcall STABLECOIN.transfer(msg.sender, repay_flash_amount, default_return_value=True)

```

--------------------------------

### Execute Token Exchange (Yield Basis)

Source: https://docs.yieldbasis.com/dev/levamm

The `exchange()` function facilitates swapping between stablecoins and LP tokens. It maintains 2x leverage and returns the actual amount of output tokens received. This function requires interaction with external contracts for price oracles and token transfers.

```solidity
@external
@nonreentrant
def exchange(i: uint256, j: uint256, in_amount: uint256, min_out: uint256, _for: address = msg.sender) -> uint256:
    assert (i == 0 and j == 1) or (i == 1 and j == 0)
    assert not self.is_killed

    collateral: uint256 = self.collateral_amount
    debt: uint256 = self._debt_w()
    p_o: uint256 = extcall PRICE_ORACLE_CONTRACT.price_w()
    x0: uint256 = self.get_x0(p_o, collateral, debt, False)
    x_initial: uint256 = x0 - debt

    out_amount: uint256 = 0
    fee: uint256 = self.fee

    if i == 0:  # Trader buys collateral from us
        x: uint256 = x_initial + in_amount
        y: uint256 = math._ceil_div(x_initial * collateral, x)
        out_amount = (collateral - y) * (10**18 - fee) // 10**18
        assert out_amount >= min_out, "Slippage"
        debt -= in_amount
        collateral -= out_amount
        self.redeemed += in_amount
        assert extcall STABLECOIN.transferFrom(msg.sender, self, in_amount, default_return_value=True)
        assert extcall COLLATERAL.transfer(_for, out_amount, default_return_value=True)

    else:  # Trader sells collateral to us
        y: uint256 = collateral + in_amount
        x: uint256 = math._ceil_div(x_initial * collateral, y)
        out_amount = (x_initial - x) * (10**18 - fee) // 10**18
        assert out_amount >= min_out, "Slippage"
        debt += out_amount
        self.minted += out_amount
        collateral = y
        assert extcall COLLATERAL.transferFrom(msg.sender, self, in_amount, default_return_value=True)
        assert extcall STABLECOIN.transfer(_for, out_amount, default_return_value=True)

    assert self.get_x0(p_o, collateral, debt, True) >= x0, "Bad final state"
    self.collateral_amount = collateral
    self.debt = debt

    log TokenExchange(buyer=msg.sender, sold_id=i, tokens_sold=in_amount,
                      bought_id=j, tokens_bought=out_amount, fee=fee, price_oracle=p_o)

    if LT_CONTRACT != empty(address) and LT_CONTRACT.is_contract:
        self._collect_fees()
        extcall LT(LT_CONTRACT).distribute_borrower_fees()

    return out_amount
```

--------------------------------

### GET /get_gauge_weight

Source: https://docs.yieldbasis.com/dev/gauge-controller

Returns the current raw weight of a specified gauge, without any adjustments.

```APIDOC
## GET /get_gauge_weight

### Description
Returns the current weight of a gauge. This is the raw weight value without any adjustments applied.

### Method
GET

### Endpoint
/get_gauge_weight

### Parameters
#### Path Parameters
None

#### Query Parameters
- **addr** (address) - Required - The address of the gauge to query.

#### Request Body
None

### Request Example
```bash
GET /get_gauge_weight?addr=0x...
```

### Response
#### Success Response (200)
- **weight** (uint256) - The current raw weight of the gauge.

#### Response Example
```json
{
  "weight": 1000000000000000000
}
```

### Requirements
- Gauge must be registered (time_weight[addr] > 0).
```

--------------------------------

### Execute Token Swaps with VirtualPool Vyper

Source: https://docs.yieldbasis.com/dev/virtual-pool

The `exchange` function in the VirtualPool contract executes swaps between stablecoins and crypto assets. It leverages flash loans for internal liquidity management and returns the amount of output tokens received, emitting a `TokenExchange` event upon successful execution. Input validation ensures opposite token indices and sufficient output amounts.

```vyper
interface Flash:
    def flashLoan(receiver: address, token: address, amount: uint256, data: Bytes[10**5]) -> bool: nonpayable
    def supportedTokens(token: address) -> bool: view
    def maxFlashLoan(token: address) -> uint256: view

ASSET_TOKEN: public(immutable(ERC20))
STABLECOIN: public(immutable(ERC20))

@external
@nonreentrant
def exchange(i: uint256, j: uint256, in_amount: uint256, min_out: uint256, _for: address = msg.sender) -> uint256:
    assert (i == 0 and j == 1) or (i == 1 and j == 0)
    flash: Flash = staticcall FACTORY.flash()

    in_coin: ERC20 = [STABLECOIN, ASSET_TOKEN][i]
    out_coin: ERC20 = [STABLECOIN, ASSET_TOKEN][j]

    assert extcall in_coin.transferFrom(msg.sender, self, in_amount, default_return_value=True)

    data: Bytes[128] = empty(Bytes[128])
    data = abi_encode(i, in_amount)
    extcall flash.flashLoan(self, STABLECOIN.address, staticcall flash.maxFlashLoan(STABLECOIN.address), data)

    out_amount: uint256 = staticcall out_coin.balanceOf(self)
    assert out_amount >= min_out, "Slippage"
    assert extcall out_coin.transfer(_for, out_amount, default_return_value=True)

    log TokenExchange(buyer=_for, sold_id=i, tokens_sold=in_amount, bought_id=j, tokens_bought=out_amount)
    return out_amount
```

--------------------------------

### GET /gauge_relative_weight

Source: https://docs.yieldbasis.com/dev/gauge-controller

Returns the relative weight of a gauge, normalized to 1e18, indicating its proportion of total emissions.

```APIDOC
## GET /gauge_relative_weight

### Description
Returns the relative weight of a gauge normalized to 1e18 (1.0 = 1e18). This represents the proportion of total emissions the gauge will receive.

### Method
GET

### Endpoint
/gauge_relative_weight

### Parameters
#### Path Parameters
None

#### Query Parameters
- **gauge** (address) - Required - The address of the gauge.

#### Request Body
None

### Request Example
```bash
GET /gauge_relative_weight?gauge=0x...
```

### Response
#### Success Response (200)
- **relative_weight** (uint256) - The relative weight of the gauge normalized to 1e18.

#### Response Example
```json
{
  "relative_weight": 500000000000000000
}
```

### Requirements
- Gauge must be registered (time_weight[gauge] > 0).
```

--------------------------------

### Get Token Symbol

Source: https://docs.yieldbasis.com/dev/lt

Returns the token symbol in the format 'yb-asset', implementing the ERC20 symbol standard.

```APIDOC
## GET /symbol

### Description
Returns the token symbol in the format 'yb-asset'. This implements the ERC20 symbol standard.

### Method
GET

### Endpoint
/symbol

### Parameters
None

### Request Body
None

### Response
#### Success Response (200)
- **symbol** (String[32]) - Token symbol (e.g., "yb-BTC").

#### Response Example
```json
{
  "symbol": "yb-BTC"
}
```
```

--------------------------------

### POST /exchange

Source: https://docs.yieldbasis.com/dev/levamm

Main trading function that swaps between stablecoins and LP tokens. Users can exchange stablecoins for LP tokens or vice versa, with the AMM maintaining constant 2x leverage throughout the process.

```APIDOC
## POST /exchange

### Description
Main trading function that swaps between stablecoins and LP tokens. Users can exchange stablecoins for LP tokens or vice versa, with the AMM maintaining constant 2x leverage throughout the process.

### Method
POST

### Endpoint
/exchange

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **i** (uint256) - Required - Input token index (0=stablecoin, 1=LP token)
- **j** (uint256) - Required - Output token index (must be opposite of i)
- **in_amount** (uint256) - Required - Amount of input tokens to swap
- **min_out** (uint256) - Required - Minimum acceptable output amount (slippage protection)
- **_for** (address) - Optional - Recipient address for output tokens (defaults to msg.sender)

### Request Example
```json
{
  "i": 0,
  "j": 1,
  "in_amount": "1000000000000000000",
  "min_out": "950000000000000000",
  "_for": "0x1234567890abcdef1234567890abcdef12345678"
}
```

### Response
#### Success Response (200)
- **output_amount** (uint256) - The actual amount of output tokens received after the swap.

#### Response Example
```json
{
  "output_amount": "980000000000000000"
}
```
```

--------------------------------

### Get Total Voting Power - Vyper

Source: https://docs.yieldbasis.com/dev/voting-escrow

Returns the current total voting power across all users. This is a view function.

```vyper
@external
@view
def totalVotes() -> uint256:
    return self.total_supply_at(block.timestamp)

```

--------------------------------

### exchange()

Source: https://docs.yieldbasis.com/dev/virtual-pool

Executes swaps between stablecoins and crypto assets within the VirtualPool. This function allows users to exchange one asset for another using flash loans.

```APIDOC
## exchange()

### Description
Executes swaps between stablecoins and crypto assets. Users can exchange one asset for another through the virtual pool mechanism, which uses flash loans to perform the swap without requiring users to hold LP tokens.

### Method
EXTERNAL

### Endpoint
VirtualPool.exchange

### Parameters
| Input       | Type      | Description                                            |
| ----------- | --------- | ------------------------------------------------------ |
| `i`         | `uint256` | Input token index (0=stablecoin, 1=crypto)             |
| `j`         | `uint256` | Output token index (must be opposite of `i`)           |
| `in_amount` | `uint256` | Amount of input tokens to swap                         |
| `min_out`   | `uint256` | Minimum acceptable output amount (slippage protection) |
| `_for`      | `address` | Recipient address for output tokens (defaults to msg.sender)|

### Request Example
```json
{
  "i": 0,
  "j": 1,
  "in_amount": 1000000,
  "min_out": 990000,
  "_for": "0xRecipientAddress"
}
```

### Response
#### Success Response (200)
- **uint256** - The actual amount of output tokens received after the swap.

#### Response Example
```json
{
  "out_amount": 995000
}
```

```

--------------------------------

### Get Token Name

Source: https://docs.yieldbasis.com/dev/lt

Returns the token name in the format 'Yield Basis liquidity for asset', implementing the ERC20 name standard.

```APIDOC
## GET /name

### Description
Returns the token name in the format 'Yield Basis liquidity for asset'. This implements the ERC20 name standard.

### Method
GET

### Endpoint
/name

### Parameters
None

### Request Body
None

### Response
#### Success Response (200)
- **name** (String[58]) - Token name (e.g., "Yield Basis liquidity for BTC").

#### Response Example
```json
{
  "name": "Yield Basis liquidity for BTC"
}
```
```

--------------------------------

### Deposit LP Tokens and Borrow Stablecoins

Source: https://docs.yieldbasis.com/dev/levamm

An internal function, callable only by the LT contract, for depositing LP tokens and borrowing stablecoins. It updates internal state variables for collateral and debt, mints stablecoins, and logs the liquidity addition event. It returns the oracle price and the calculated value after the deposit.

```Solidity
@external  
def _deposit(d_collateral: uint256, d_debt: uint256) -> OraclizedValue:  
    assert msg.sender == LT_CONTRACT, "Access violation"  
    assert not self.is_killed  
  
    p_o: uint256 = extcall PRICE_ORACLE_CONTRACT.price_w()  
    collateral: uint256 = self.collateral_amount  
    debt: uint256 = self._debt_w()  
  
    debt += d_debt  
    collateral += d_collateral  
    self.minted += d_debt  
  
    self.debt = debt  
    self.collateral_amount = collateral  
  
    value_after: uint256 = self.get_x0(p_o, collateral, debt, True) * 10**18 // (2 * LEVERAGE - 10**18)  
  
    log AddLiquidityRaw(token_amounts=[d_collateral, d_debt], invariant=value_after, price_oracle=p_o)  
    return OraclizedValue(p_o=p_o, value=value_after)  

```

--------------------------------

### Get Price Per Share

Source: https://docs.yieldbasis.com/dev/lt

Retrieves the non-manipulatable "fair price per share" oracle of the yb-asset token.

```APIDOC
## GET /pricePerShare

### Description
Non-manipulatable "fair price per share" oracle of the yb-asset token.

### Method
GET

### Endpoint
/pricePerShare

### Parameters
None

### Request Body
None

### Response
#### Success Response (200)
- **pricePerShare** (uint256) - Price per share in 1e18 units.

#### Response Example
```json
{
  "pricePerShare": "1000000000000000000"
}
```
```

--------------------------------

### GET /get_adjustment

Source: https://docs.yieldbasis.com/dev/liquidity-gauge

Returns the adjustment factor based on the gauge's share of total LP supply. This is used by GaugeController for weight calculations.

```APIDOC
## GET /get_adjustment

### Description
Returns the adjustment factor based on the gauge's share of total LP supply. Used by GaugeController for weight calculations.

### Method
GET

### Endpoint
/get_adjustment

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{} 
```

### Response
#### Success Response (200)
- **adjustment_factor** (uint256) - Adjustment factor (square root of gauge's LP share).

#### Response Example
```json
{
  "adjustment_factor": "9500"
}
```
```

--------------------------------

### coins()

Source: https://docs.yieldbasis.com/dev/levamm

Returns the token address for the given index. Index 0 returns the stablecoin address, and index 1 returns the LP token address.

```APIDOC
## coins()

### Description
Returns the token address for the given index. Index 0 returns the stablecoin address, index 1 returns the LP token address.

### Method
GET

### Endpoint
/websites/yieldbasis

### Parameters
#### Query Parameters
- **i** (uint256) - Required - Token index (0=stablecoin, 1=LP token)

### Response
#### Success Response (200)
- **address** (IERC20) - Token contract address

#### Response Example
```json
{
  "address": "0x..."
}
```
```

--------------------------------

### GET /get_rate_mul

Source: https://docs.yieldbasis.com/dev/levamm

Retrieves the current rate multiplier, which is used to calculate the total accumulated interest based on the time elapsed and the current interest rate.

```APIDOC
## GET /get_rate_mul

### Description
Returns the current rate multiplier which represents 1.0 + integral(rate, dt). This is used to calculate accumulated interest over time.

### Method
GET

### Endpoint
/get_rate_mul

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **rate_mul** (uint256) - The rate multiplier in units where 1.0 == 1e18.

#### Response Example
```json
{
  "rate_mul": "1005000000000000000"
}
```
```

--------------------------------

### Factory Contract for Market Registry and Deployment

Source: https://docs.yieldbasis.com/dev/overview

The Factory contract in the YieldBasis system is responsible for deploying and managing all market instances. It acts as a central registry and an upgrade mechanism, controlled via veYB.

```vyper
contract Factory {
    // ... implementation details ...
}
```

--------------------------------

### Get Past Total Supply - Vyper

Source: https://docs.yieldbasis.com/dev/voting-escrow

Returns the total voting power at a specific moment in the past. This function works with both past and future timestamps. It requires a timestamp as input.

```vyper
@external
@view
def getPastTotalSupply(timepoint: uint256) -> uint256:
    return self.total_supply_at(timepoint)

```

--------------------------------

### POST /_deposit

Source: https://docs.yieldbasis.com/dev/levamm

Internal function for the LT contract to deposit LP tokens and borrow stablecoins. This function is restricted to calls from the LT contract and emits an AddLiquidityRaw event.

```APIDOC
## POST /_deposit

### Description
Internal function for the LT contract to deposit LP tokens and borrow stablecoins. This function can only be called by the LT contract.

### Method
POST

### Endpoint
/_deposit

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **d_collateral** (uint256) - Required - LP tokens to add.
- **d_debt** (uint256) - Required - Stablecoins to borrow.

### Request Example
```json
{
  "d_collateral": "500000000000000000",
  "d_debt": "250000000000000000"
}
```

### Response
#### Success Response (200)
- **p_o** (uint256) - Oracle price.
- **value** (uint256) - USD value after deposit.

#### Response Example
```json
{
  "p_o": "2000000000000000000",
  "value": "750000000000000000"
}
```
```

--------------------------------

### Data Structs: AMMState

Source: https://docs.yieldbasis.com/dev/virtual-pool

Describes the AMMState data structure.

```APIDOC
## Data Structs: AMMState

### Description
This describes the AMMState data structure.

### Variables
- **`collateral`** (`uint256`) - LP token amount held as collateral
- **`debt`** (`uint256`) - Interest-accrued stablecoin debt
- **`x0`** (`uint256`) - Virtual balance for maintaining leverage
```

--------------------------------

### Get User's Lock End Time

Source: https://docs.yieldbasis.com/dev/voting-escrow

Returns the timestamp at which a user's locked position is scheduled to end. This is a view function used to check lock durations.

```vyper
@external
@view
def locked__end(_addr: address) -> uint256:
    return self.locked[_addr].end

```

--------------------------------

### Get Current Voting Power - Vyper

Source: https://docs.yieldbasis.com/dev/voting-escrow

Returns the current voting power for a user account. Voting power decays linearly over time. Requires the user's account address as input.

```vyper
@external
@view
def getVotes(account: address) -> uint256:
    _epoch: uint256 = self.user_point_epoch[account]
    if _epoch == 0:
        return 0
    else:
        last_point: Point = self.user_point_history[account][_epoch]
        last_point.bias -= last_point.slope * convert(block.timestamp - last_point.ts, int256)
        if last_point.bias < 0:
            last_point.bias = 0
        return convert(last_point.bias, uint256)

```

--------------------------------

### Public Variables: Contract Addresses

Source: https://docs.yieldbasis.com/dev/virtual-pool

Lists the public contract address variables in the VirtualPool. These define core contract dependencies.

```APIDOC
## Public Variables: Contract Addresses

### Description
These are the public contract address variables exposed by the VirtualPool contract.

### Variables
- **`FACTORY`** (`Factory`) - Factory contract address (immutable)
- **`AMM`** (`YbAMM`) - YieldBasis AMM contract address (immutable)
- **`POOL`** (`Pool`) - Curve pool contract address (immutable)
- **`ASSET_TOKEN`** (`ERC20`) - Crypto asset token address (immutable)
- **`STABLECOIN`** (`ERC20`) - Stablecoin token address (immutable)
- **`IMPL`** (`address`) - Implementation address (immutable)
```

--------------------------------

### Preview Claimable Rewards (Vyper)

Source: https://docs.yieldbasis.com/dev/liquidity-gauge

The `preview_claim` function allows users to see how many rewards they can claim without actually executing the claim transaction. It returns a preview of the claimable rewards. The function checks for YB token rewards or other registered reward tokens.

```vyper
@external
@view
def preview_claim(reward: IERC20, user: address) -> uint256:
    d_reward: uint256 = 0
    if reward == YB:
        d_reward = staticcall GC.preview_emissions(self, block.timestamp)
    else:
        d_reward = self._get_vested_rewards(reward)

    r: RewardIntegrals = self._checkpoint(reward, d_reward, user)
    return r.user_rewards_integral.v - self.claimed_rewards[user][reward]

```

--------------------------------

### Get User's Last Voting Power Slope

Source: https://docs.yieldbasis.com/dev/voting-escrow

Retrieves the most recent slope value, representing the rate of voting power decrease for a given user. This is a view function and does not modify the contract state.

```vyper
@external
@view
def get_last_user_slope(addr: address) -> int256:
    uepoch: uint256 = self.user_point_epoch[addr]
    return self.user_point_history[addr][uepoch].slope

```
Tokens:
Raw