Vulnerability: Cannot permissionless settle the vault account if the user use a blacklisted account
Severity: medium

Description:
Cannot permissionless settle the vault account if the user use a blacklisted account\\nIn VaultAccoutnAction.sol, one of the critical function is\\n```\\n    /// @notice Settles a matured vault account by transforming it from an fCash maturity into\\n    /// a prime cash account. This method is not authenticated, anyone can settle a vault account\\n    /// without permission. Generally speaking, this action is economically equivalent no matter\\n    /// when it is called. In some edge conditions when the vault is holding prime cash, it is\\n    /// advantageous for the vault account to have this called sooner. All vault account actions\\n    /// will first settle the vault account before taking any further actions.\\n    /// @param account the address to settle\\n    /// @param vault the vault the account is in\\n    function settleVaultAccount(address account, address vault) external override nonReentrant {\\n        requireValidAccount(account);\\n        require(account != vault);\\n\\n        VaultConfig memory vaultConfig = VaultConfiguration.getVaultConfigStateful(vault);\\n        VaultAccount memory vaultAccount = VaultAccountLib.getVaultAccount(account, vaultConfig);\\n        \\n        // Require that the account settled, otherwise we may leave the account in an unintended\\n        // state in this method because we allow it to skip the min borrow check in the next line.\\n        (bool didSettle, bool didTransfer) = vaultAccount.settleVaultAccount(vaultConfig);\\n        require(didSettle, "No Settle");\\n\\n        vaultAccount.accruePrimeCashFeesToDebt(vaultConfig);\\n\\n        // Skip Min Borrow Check so that accounts can always be settled\\n        vaultAccount.setVaultAccount({vaultConfig: vaultConfig, checkMinBorrow: false});\\n\\n        if (didTransfer) {\\n            // If the vault did a transfer (i.e. withdrew cash) we have to check their collateral ratio. There\\n            // is an edge condition where a vault with secondary borrows has an emergency exit. During that process\\n            // an account will be left some cash balance in both currencies. It may have excess cash in one and\\n            // insufficient cash in the other. A withdraw of the excess in one side will cause the vault account to\\n            // be insolvent if we do not run this check. If this scenario indeed does occur, the vault itself must\\n            // be upgraded in order to facilitate orderly exits for all of the accounts since they will be prevented\\n            // from settling.\\n            IVaultAccountHealth(address(this)).checkVaultAccountCollateralRatio(vault, account);\\n        }\\n    }\\n```\\n\\nas the comment suggests, this function should be called permissionless\\nand the comment is, which means there should not be able to permissionless reject account settlement\\n```\\n/// will first settle the vault account before taking any further actions.\\n```\\n\\nthis is calling\\n```\\n  (bool didSettle, bool didTransfer) = vaultAccount.settleVaultAccount(vaultConfig);\\n```\\n\\nwhich calls\\n```\\n    /// @notice Settles a matured vault account by transforming it from an fCash maturity into\\n    /// a prime cash account. This method is not authenticated, anyone can settle a vault account\\n    /// without permission. Generally speaking, this action is economically equivalent no matter\\n    /// when it is called. In some edge conditions when the vault is holding prime cash, it is\\n    /// advantageous for the vault account to have this called sooner. All vault account actions\\n    /// will first settle the vault account before taking any further actions.\\n    /// @param account the address to settle\\n    /// @param vault the vault the account is in\\n    function settleVaultAccount(address account, address vault) external override nonReentrant {\\n        requireValidAccount(account);\\n        require(account != vault);\\n\\n        VaultConfig memory vaultConfig = VaultConfiguration.getVaultConfigStateful(vault);\\n        VaultAccount memory vaultAccount = VaultAccountLib.getVaultAccount(account, vaultConfig);\\n        \\n        // Require that the account settled, otherwise we may leave the account in an unintended\\n        // state in this method because we allow it to skip the min borrow check in the next line.\\n        (bool didSettle, bool didTransfer) = vaultAccount.settleVaultAccount(vaultConfig);\\n        require(didSettle, "No Settle");\\n```\\n\\nbasically this calls\\n```\\n        // Calculates the net settled cash if there is any temp cash balance that is net off\\n        // against the settled prime debt.\\n        bool didTransferPrimary;\\n        (accountPrimeStorageValue, didTransferPrimary) = repayAccountPrimeDebtAtSettlement(\\n            vaultConfig.primeRate,\\n            primeVaultState,\\n            vaultConfig.borrowCurrencyId,\\n            vaultConfig.vault,\\n            vaultAccount.account,\\n            vaultAccount.tempCashBalance,\\n            accountPrimeStorageValue\\n        );\\n```\\n\\ncalling\\n```\\n    function repayAccountPrimeDebtAtSettlement(\\n        PrimeRate memory pr,\\n        VaultStateStorage storage primeVaultState,\\n        uint16 currencyId,\\n        address vault,\\n        address account,\\n        int256 accountPrimeCash,\\n        int256 accountPrimeStorageValue\\n    ) internal returns (int256 finalPrimeDebtStorageValue, bool didTransfer) {\\n        didTransfer = false;\\n        finalPrimeDebtStorageValue = accountPrimeStorageValue;\\n        \\n        if (accountPrimeCash > 0) {\\n            // netPrimeDebtRepaid is a negative number\\n            int256 netPrimeDebtRepaid = pr.convertUnderlyingToDebtStorage(\\n                pr.convertToUnderlying(accountPrimeCash).neg()\\n            );\\n\\n            int256 netPrimeDebtChange;\\n            if (netPrimeDebtRepaid < accountPrimeStorageValue) {\\n                // If the net debt change is greater than the debt held by the account, then only\\n                // decrease the total prime debt by what is held by the account. The residual amount\\n                // will be refunded to the account via a direct transfer.\\n                netPrimeDebtChange = accountPrimeStorageValue;\\n                finalPrimeDebtStorageValue = 0;\\n\\n                int256 primeCashRefund = pr.convertFromUnderlying(\\n                    pr.convertDebtStorageToUnderlying(netPrimeDebtChange.sub(accountPrimeStorageValue))\\n                );\\n                TokenHandler.withdrawPrimeCash(\\n                    account, currencyId, primeCashRefund, pr, false // ETH will be transferred natively\\n                );\\n                didTransfer = true;\\n            } else {\\n                // In this case, part of the account's debt is repaid.\\n                netPrimeDebtChange = netPrimeDebtRepaid;\\n                finalPrimeDebtStorageValue = accountPrimeStorageValue.sub(netPrimeDebtRepaid);\\n            }\\n```\\n\\nthe token withdrawal logic above try to push ETH to accout\\n```\\nTokenHandler.withdrawPrimeCash(\\n account, currencyId, primeCashRefund, pr, false // ETH will be transferred natively\\n);\\n```\\n\\nthis is calling\\n```\\n  function withdrawPrimeCash(\\n        address account,\\n        uint16 currencyId,\\n        int256 primeCashToWithdraw,\\n        PrimeRate memory primeRate,\\n        bool withdrawWrappedNativeToken\\n    ) internal returns (int256 netTransferExternal) {\\n        if (primeCashToWithdraw == 0) return 0;\\n        require(primeCashToWithdraw < 0);\\n\\n        Token memory underlying = getUnderlyingToken(currencyId);\\n        netTransferExternal = convertToExternal(\\n            underlying, \\n            primeRate.convertToUnderlying(primeCashToWithdraw) \\n        );\\n\\n        // Overflow not possible due to int256\\n        uint256 withdrawAmount = uint256(netTransferExternal.neg());\\n        _redeemMoneyMarketIfRequired(currencyId, underlying, withdrawAmount);\\n\\n        if (underlying.tokenType == TokenType.Ether) {\\n            GenericToken.transferNativeTokenOut(account, withdrawAmount, withdrawWrappedNativeToken);\\n        } else {\\n            GenericToken.safeTransferOut(underlying.tokenAddress, account, withdrawAmount);\\n        }\\n\\n        _postTransferPrimeCashUpdate(account, currencyId, netTransferExternal, underlying, primeRate);\\n    }\\n```\\n\\nnote the function call\\n```\\nif (underlying.tokenType == TokenType.Ether) {\\n GenericToken.transferNativeTokenOut(account, withdrawAmount, withdrawWrappedNativeToken);\\n} else {\\n GenericToken.safeTransferOut(underlying.tokenAddress, account, withdrawAmount);\\n}\\n```\\n\\nif the token type is not ETHER,\\nwe are transfer the underlying ERC20 token to the account\\n```\\nGenericToken.safeTransferOut(underlying.tokenAddress, account, withdrawAmount);\\n```\\n\\nthe token in-scoped is\\n```\\nERC20:  Any Non-Rebasing token. ex. USDC, DAI, USDT (future), wstETH, WETH, WBTC, FRAX, CRV, etc.\\n```\\n\\nUSDC is common token that has blacklisted\\nif the account is blacklisted, the transfer would revert and the account cannot be settled!

Impact:
what are the impact,\\nper comment\\n```\\n/// will first settle the vault account before taking any further actions.\\n```\\n\\nif that is too vague, I can list three, there are more!\\nthere are certain action that need to be done after the vault settlement, for example, liqudation require the vault settlement first\\nthere are case that require force vault settlement, actually one example is notional need to force the settle the vault during migration! (this is just the case to show user should be able to permissionless reject settlement)

Recommended mitigation:
maybe let admin bypass the withdrawPrimeCash and force settle the account to not let settlement block further action!