Oven V2

​

Oven Summary

The Oven infrastructure manages baking, or pooled entry into a position.

The Oven accepts a single token. It uses a recipe, which can combine many steps such as swapping for several assets and depositing them in various strategies or LPs, to compose a single output token.

EthOven.sol

  • constructor

    • _weth

    • _outputToken

    • _roundSize

  • receive

    • Receives ETH, Deposits to msg.sender

  • depositETH

    • Deposits ETH to message sender

  • depositETHTo

    • Deposits ETH to provided address

Oven.sol

  • Initializes

    • inputToken

      • address

    • outputToken

      • address

    • Recipe

      • address

    • roundeSize

      • This sets the max units of inputToken to be used per round.

      • Acts to limit slippage

    • rounds[]

      • Stores each round

    • userRounds{}

      • Maps users to rounds

    • fee

    • feeReceive

  • onlyBaker # Modifier

  • onlyAdmin # Modifier

  • constructor

    • inputToken

    • outputToken

    • roundSize

    • recipe

    • Triggers these actions:

      • creates empty rounds

      • Approves tokens

      • Sets default role

      • Sets baker role

  • deposit, depositTo, _depositTo

    • Transfers `amount` of `inputToken` from `msg.sender` to this address

    • Since each `round` has a max `roundSize` to prevent slippage, deposits loop to fill each round. Break when full `amount` assigned to `rounds`

  • pushUserRound

    • links user to `roundId` particularly useful for deposits which span into multiple rounds

  • withdraw, withdrawTo (`to`, `roundsLimit`)

    • Queries the `userRounds` and loops through participated `rounds`.

    • Calculates the relative share of baked asset the users deposit relates to in both `inputAmount` and `outputAmount`.

    • transfers `inputAmount` and `outputAmount` to entered address

    • emits `Withdraw` event

  • bake (calldata_data, memory_rounds)

    • Can only be called by `Baker` role

    • Loops through `rounds` and calculates the unbaked amount of round as `maxInputAmount`. A fee is applied if applicable.

    • `recipe.bake` is triggered which bakes `inputToken` to `outputToken`

    • `rounds` are updated with new `totalBakedInput`

    • if fee set, transfer to feeReceiver

  • setFee

    • only Admin can invoke

  • setFeeReceiver

    • only admin call invoke

  • roundInputBalanceOf (round, of)

    • returns total input token balance of a user minus baked amount

  • inputBalanceOf (of)

    • sum of `roundInputBalanaceOf` for multiple rounds

  • roundOutputBalanceOf (round, of)

    • returns total output balance of a user minus unbaked amount

  • outputBalanceOf (of)

    • sum of `roundOutputBalanceOf` for multiple rounds

  • getUserRoundsCount (user)

    • length of rounds per address

  • getRoundsCount

    • total rounds length

Recipe.sol

  • Bake

    • A recipe should route from one input token to one output token and the functionality to do so should be triggered by a `bake` function.

    • Should accept

      • _inputToken

        • address

      • _outputToken

        • address

      • _maxInput

        • Max input units unbaked for the round

        • If a fee is set, this will have applied.

    • Should return

      • inputAmountUsed

        • Defining units of inputToken spent

      • outputAmount

        • Defining units of outputToken produced.

  • Any additional function needed to compose the outputToken should be defined in the recipe.

  • For examples, please see contracts/recipes.