Renzo - m_Rassska's results

      // record token value of withdraw queue
      if (!withdrawQueueTokenBalanceRecorded) { 
          totalWithdrawalQueueValue += renzoOracle.lookupTokenValue(
+-        collateralTokens[j], 
              collateralTokens[j].balanceOf(withdrawQueue)
          );
      }

Short term:

      // withdrawalQueue total value
      uint256 totalWithdrawalQueueValue = 0;

+        for (uint i = 0; i < collateralTokens.length; i++) {
+            totalWithdrawalQueueValue += renzoOracle.lookupTokenValue(
+                collateralTokens[i], 
+                collateralTokens[i].balanceOf(withdrawQueue)
+            );
+        }


      for (uint256 i = 0; i < odLength; ) {
          // Track the TVL for this OD
          uint256 operatorTVL = 0;

          // Track the individual token TVLs for this OD - native ETH will be last item in the array
          uint256[] memory operatorValues = new uint256[](collateralTokens.length + 1);
          operatorDelegatorTokenTVLs[i] = operatorValues;

          // Iterate through the tokens and get the value of each
          uint256 tokenLength = collateralTokens.length;
          for (uint256 j = 0; j < tokenLength; ) {
              // Get the value of this token

              uint256 operatorBalance = operatorDelegators[i].getTokenBalanceFromStrategy(
                  collateralTokens[j]
              );

              // Set the value in the array for this OD
              operatorValues[j] = renzoOracle.lookupTokenValue(
                  collateralTokens[j],
                  operatorBalance
              );

              // Add it to the total TVL for this OD
              operatorTVL += operatorValues[j];

-                // record token value of withdraw queue
-                if (!withdrawQueueTokenBalanceRecorded) { // fixme: high - accounted collToken.length * OD.length
-                    totalWithdrawalQueueValue += renzoOracle.lookupTokenValue(
-                        collateralTokens[i], 
-                        collateralTokens[j].balanceOf(withdrawQueue)
-                    );
-                }

              unchecked {
                  ++j;
              }
          }

Long term:

• Consider caching all LST/ETH exchange rates first, computing the value held by WtihdrawQueue, and then looping over the ods.

          uint256 bufferToFill = depositQueue.withdrawQueue().getBufferDeficit(
          address(_collateralToken)
      );
      if (bufferToFill > 0) {
          bufferToFill = (_amount <= bufferToFill) ? _amount : bufferToFill;
          // update amount to send to the operator Delegator
          _amount -= bufferToFill;

          // safe Approve for depositQueue
          _collateralToken.safeApprove(address(depositQueue), bufferToFill);

          // fill Withdraw Buffer via depositQueue
          depositQueue.fillERC20withdrawBuffer(address(_collateralToken), bufferToFill);
      }

+        if (_amount > 0) {
          // Approve the tokens to the operator delegator
          _collateralToken.safeApprove(address(operatorDelegator), _amount);

          // Call deposit on the operator delegator
          operatorDelegator.deposit(_collateralToken, _amount);
+        }


      // Calculate how much ezETH to mint
      uint256 ezETHToMint = renzoOracle.calculateMintAmount(
          totalTVL,
          collateralTokenValue,
          ezETH.totalSupply()
      );