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.


  • constructor
    • _weth
    • _outputToken
    • _roundSize
  • receive
    • Receives ETH, Deposits to msg.sender
  • depositETH
    • Deposits ETH to message sender
  • depositETHTo
    • Deposits ETH to provided address


  • 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


  • 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.