LOW severity: [ASTRO-23] Code style problems. **Severity:** Low

**Path:** Crate.sol, Swap.sol

**Description:** In the Crate contract, the ordering of the variable declaration can be tightly packed to optimize storage usage and save gas.

In the Crate and Swap contracts there is redundant return keywords usage as the variables are declared...

Vulnerable code:
uint8 private tokenDecimals; // The decimals of the token
    uint256 public totalRemoteAssets; // Amount of assets on other chains (or farmed on local chain)
    uint256 public performanceFee; // 100% = 10000
    uint256 public managementFee; // 100% = 10000
    uint256 public withdrawFee; // 100% = 10000
    uint256 public anticipatedProfits; // The yield trickling down
    uint256 public lastUpdate; // Last time the unrealized gain was updated
    Checkpoint public checkpoint; // Used to compute fees
    ElasticLiquidityPool public liquidityPool; // The pool used to process withdraws
    bool public liquidityPoolEnabled; // If the pool is enabled
    IERC20 public asset; // The asset we are using

function mint(
        uint256 _shares,
        address _receiver
    ) external nonReentrant returns (uint256 assets) {
        assets = convertToAssets(_shares);

        // Requires
        if (assets == 0 || _shares == 0) revert AmountZero();
        if (assets > maxDeposit(_receiver))
            revert AmountTooHigh(maxDeposit(_receiver));
        if (_receiver == address(this)) revert CrateCantBeReceiver();

        // Moving value
        asset.safeTransferFrom(msg.sender, address(this), assets);
        _mint(_receiver, _shares);
        emit Deposit(msg.sender, _receiver, assets, _shares);
        return (assets);
    }

function _withdraw(
        uint256 _amount,
        uint256 _shares,
        uint256 _minAmountOut,
        uint256 _deadline,
        address _receiver,
        address _owner
    ) internal nonReentrant returns (uint256 recovered) {
        if (_amount == 0 || _shares == 0) revert AmountZero();

        // We spend the allowance if the msg.sender isn't the receiver
        if (msg.sender != _owner) {
            _spendAllowance(_owner, msg.sender, _shares);
        }

        // Check for rounding error since we round down in previewRedeem.
        if (convertToAssets(_shares) == 0)
            revert IncorrectAssetAmount(convertToAssets(_shares));

        // We burn the tokens
        _burn(_owner, _shares);

        // Allows to take a withdraw fee
        _amount = (_amount * (MAX_BPS - withdrawFee)) / MAX_BPS;

        if (liquidityPoolEnabled) {
            // We don't take into account the eventual slippage, since it will
            // be paid to the depositoors
            liquidityPool.debt -= Math.min(_amount, liquidityPool.debt);
            try
                liquidityPool.swap.swapVirtualToAsset(
                    _amount,
                    _minAmountOut,
                    _deadline,
                    _receiver
                )
            returns (uint256 dy) {
                recovered = dy;
            } catch {
                // if the swap fails, we send the funds available
                asset.safeTransfer(_receiver, _amount);
                recovered = _amount;
            }
        } else {
            // If the liquidity pool is not enabled, we send the funds available
            // This allows for the bootstrapping of the pool at start
            asset.safeTransfer(_receiver, _amount);
            recovered = _amount;
        }

        if (_minAmountOut > 0 && recovered < _minAmountOut)
            revert IncorrectAssetAmount(recovered);

        emit Withdraw(msg.sender, _receiver, _owner, _amount, _shares);
        return (recovered);
    }