Farseen0/scar-pairs huggingface dataset:
MEDIUM severity: Vulnerable function: ```\nfunction getParentAndBlockhash(bytes memory \_blockheader) public pure returns (bytes32 parentH. ```\nfunction getParentAndBlockhash(bytes memory \_blockheader) public pure returns (bytes32 parentHash, bytes32 bhash) {\n\n    /// we need the 1st byte of the blockheader to calculate the position of the parentHash\n    uint8 first = uint8(\_blockheader[0]);\n\n    /// calculates the offset\n    /

Vulnerable code:
```\nfunction getParentAndBlockhash(bytes memory \_blockheader) public pure returns (bytes32 parentHash, bytes32 bhash) {\n\n    /// we need the 1st byte of the blockheader to calculate the position of the parentHash\n    uint8 first = uint8(\_blockheader[0]);\n\n    /// calculates the offset\n    /// by using the 1st byte (usually f9) and substracting f7 to get the start point of the parentHash information\n    /// we also have to add "2" = 1 byte to it to skip the length-information\n    require(first > 0xf7, "invalid offset");\n    uint8 offset = first - 0xf7 + 2;\n\n    /// we are using assembly because it's the most efficent way to access the parent blockhash within the rlp-encoded blockheader\n    // solium-disable-next-line security/no-inline-assembly\n    assembly { // solhint-disable-line no-inline-assembly\n        // mstore to get the memory pointer of the blockheader to 0x20\n        mstore(0x20, \_blockheader)\n\n        // we load the pointer we just stored\n        // then we add 0x20 (32 bytes) to get to the start of the blockheader\n        // then we add the offset we calculated\n        // and load it to the parentHash variable\n        parentHash :=mload(\n            add(\n                add(\n                    mload(0x20), 0x20\n                ), offset)\n        )\n    }\n    bhash = keccak256(\_blockheader);\n```\n
HIGH severity: Vulnerable function: ```\nuint256 messageNumber = nextMessageNumber;\nuint256 valueSent = msg.value -. ```\nuint256 messageNumber = nextMessageNumber;\nuint256 valueSent = msg.value - \_fee;\n\nbytes32 messageHash = keccak256(abi.encode(msg.sender, \_to, \_fee, valueSent, messageNumber, \_calldata));\n```\n

Vulnerable code:
```\nuint256 messageNumber = nextMessageNumber;\nuint256 valueSent = msg.value - \_fee;\n\nbytes32 messageHash = keccak256(abi.encode(msg.sender, \_to, \_fee, valueSent, messageNumber, \_calldata));\n```\n
HIGH severity: Vulnerable function: ```\n## Balancer.sol\n\nif (address(this).balance < _amount) revert ExceedsBalan. ```\n## Balancer.sol\n\nif (address(this).balance < _amount) revert ExceedsBalance();\n        uint256 valueAmount = msg.value + _amount;\n        routerETH.swapETH{value: valueAmount}(\n            _dstChainId,\n            payable(this),\n            abi.encodePacked(connectedOFTs[_oft][_dstChainI

Vulnerable code:
```\n## Balancer.sol\n\nif (address(this).balance < _amount) revert ExceedsBalance();\n        uint256 valueAmount = msg.value + _amount;\n        routerETH.swapETH{value: valueAmount}(\n            _dstChainId,\n            payable(this),\n            abi.encodePacked(connectedOFTs[_oft][_dstChainId].dstOft),\n            _amount,\n            _computeMinAmount(_amount, _slippage)\n        );\n```\n
MEDIUM severity: Vulnerable function: ```\nstrategyToken = (totalBPTHeld == 0) ?  bptClaim : (bptClaim * totalStrategy. ```\nstrategyToken = (totalBPTHeld == 0) ?  bptClaim : (bptClaim * totalStrategyToken) / totalBPTHeld\n```\n

Vulnerable code:
```\nstrategyToken = (totalBPTHeld == 0) ?  bptClaim : (bptClaim * totalStrategyToken) / totalBPTHeld\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction _giveAllowances() private {\n    IERC20Metadata(lpToken0).forceApprove(unirouter, type. ```\nfunction _giveAllowances() private {\n    IERC20Metadata(lpToken0).forceApprove(unirouter, type(uint256).max);\n    IERC20Metadata(lpToken1).forceApprove(unirouter, type(uint256).max);\n}\n```\n

Vulnerable code:
```\nfunction _giveAllowances() private {\n    IERC20Metadata(lpToken0).forceApprove(unirouter, type(uint256).max);\n    IERC20Metadata(lpToken1).forceApprove(unirouter, type(uint256).max);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n   IUserManager(userManager).updateLocked(msg.sender, uint96(amount + fee),. ```\n   IUserManager(userManager).updateLocked(msg.sender, uint96(amount + fee), true);\n  …\n  IUserManager(userManager).updateLocked(borrower, uint96(repayAmount - interest), false);\n```\n

Vulnerable code:
```\n   IUserManager(userManager).updateLocked(msg.sender, uint96(amount + fee), true);\n  …\n  IUserManager(userManager).updateLocked(borrower, uint96(repayAmount - interest), false);\n```\n
MEDIUM severity: Vulnerable function: ```\n  it('5) Grief xChainController send funds to vaults', async function () {\n    await xChainCon. ```\n  it('5) Grief xChainController send funds to vaults', async function () {\n    await xChainController.sendFundsToVault(vaultNumber, slippage, 10000, 0, { value: 0, });\n    await xChainController.sendFundsToVault(vaultNumber, slippage, 10000, 0, { value: 0, });\n    await xChainController.send

Vulnerable code:
```\n  it('5) Grief xChainController send funds to vaults', async function () {\n    await xChainController.sendFundsToVault(vaultNumber, slippage, 10000, 0, { value: 0, });\n    await xChainController.sendFundsToVault(vaultNumber, slippage, 10000, 0, { value: 0, });\n    await xChainController.sendFundsToVault(vaultNumber, slippage, 10000, 0, { value: 0, });\n    await xChainController.sendFundsToVault(vaultNumber, slippage, 10000, 0, { value: 0, });\n\n    expect(await xChainController.getFundsReceivedState(vaultNumber)).to.be.equal(0);\n\n    expect(await vault3.state()).to.be.equal(3);\n\n    // can't trigger state change anymore\n    await expect(xChainController.sendFundsToVault(vaultNumber, slippage, 1000, relayerFee, {value: parseEther('0.1'),})).to.be.revertedWith('Not all funds received');\n  });\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction _propose(string memory _proposalMessage, uint256 _blockNumber, uint256 _totalVotingPow. ```\nfunction _propose(string memory _proposalMessage, uint256 _blockNumber, uint256 _totalVotingPower, bytes calldata _payload) internal returns (uint256) {\n```\n

Vulnerable code:
```\nfunction _propose(string memory _proposalMessage, uint256 _blockNumber, uint256 _totalVotingPower, bytes calldata _payload) internal returns (uint256) {\n```\n
HIGH severity: Vulnerable function: ```\n    function getStablePoolTokenPrice(\n        address,\n        uint8 outputDecimals_,\n      . ```\n    function getStablePoolTokenPrice(\n        address,\n        uint8 outputDecimals_,\n        bytes calldata params_\n    ) external view returns (uint256) {\n        // Prevent overflow\n        if (outputDecimals_ > BASE_10_MAX_EXPONENT)\n            revert Balancer_OutputDecimalsOutOfBoun

Vulnerable code:
```\n    function getStablePoolTokenPrice(\n        address,\n        uint8 outputDecimals_,\n        bytes calldata params_\n    ) external view returns (uint256) {\n        // Prevent overflow\n        if (outputDecimals_ > BASE_10_MAX_EXPONENT)\n            revert Balancer_OutputDecimalsOutOfBounds(outputDecimals_, BASE_10_MAX_EXPONENT);\n\n\n        address[] memory tokens;\n        uint256 poolRate; // pool decimals\n        uint8 poolDecimals;\n        bytes32 poolId;\n        {\n\n        // rest of code// rest of code\n\n            // Get tokens in the pool from vault\n            (address[] memory tokens_, , ) = balVault.getPoolTokens(poolId);\n            tokens = tokens_;\n\n            // Get rate\n            try pool.getRate() returns (uint256 rate_) {\n                if (rate_ == 0) {\n                    revert Balancer_PoolStableRateInvalid(poolId, 0);\n                }\n\n\n                poolRate = rate_;\n\n        // rest of code// rest of code\n\n        uint256 minimumPrice; // outputDecimals_\n        {\n            /**\n             * The Balancer docs do not currently state this, but a historical version noted\n             * that getRate() should be multiplied by the minimum price of the tokens in the\n             * pool in order to get a valuation. This is the same approach as used by Curve stable pools.\n             */\n            for (uint256 i; i < len; i++) {\n                address token = tokens[i];\n                if (token == address(0)) revert Balancer_PoolTokenInvalid(poolId, i, token);\n\n                (uint256 price_, ) = _PRICE().getPrice(token, PRICEv2.Variant.CURRENT); // outputDecimals_\n\n\n                if (minimumPrice == 0) {\n                    minimumPrice = price_;\n                } else if (price_ < minimumPrice) {\n                    minimumPrice = price_;\n                }\n            }\n        }\n\n        uint256 poolValue = poolRate.mulDiv(minimumPrice, 10 ** poolDecimals); // outputDecimals_\n```\n
MEDIUM severity: Vulnerable function: ```\naddress pair = GoatV1Factory(FACTORY).getPool(token);\n\nIERC20(pair).safeT. ```\naddress pair = GoatV1Factory(FACTORY).getPool(token);\n\nIERC20(pair).safeTransferFrom(msg.sender, pair, liquidity); //-> 1. Transfers liquidity tokens to the pair\n(amountWeth, amountToken) = GoatV1Pair(pair).burn(to); //-> 2. Burns the liquidity tokens and sends WETH and TOKEN to the recipien

Vulnerable code:
```\naddress pair = GoatV1Factory(FACTORY).getPool(token);\n\nIERC20(pair).safeTransferFrom(msg.sender, pair, liquidity); //-> 1. Transfers liquidity tokens to the pair\n(amountWeth, amountToken) = GoatV1Pair(pair).burn(to); //-> 2. Burns the liquidity tokens and sends WETH and TOKEN to the recipient\nif (amountWeth < wethMin) { //-> 3. Ensures enough WETH has been transferred\n    revert GoatErrors.InsufficientWethAmount();\n}\nif (amountToken < tokenMin) { //4. Ensures enough TOKEN has been transferred\n    revert GoatErrors.InsufficientTokenAmount();\n}\n```\n
HIGH severity: Vulnerable function: ```\n        function claimSigner() public virtual {\n             if (signerCount == maxSigners) {\. ```\n        function claimSigner() public virtual {\n             if (signerCount == maxSigners) {\n                revert MaxSignersReached();\n        }\n        if (safe.isOwner(msg.sender)) {\n                revert SignerAlreadyClaimed(msg.sender);\n            }\n        if (!isValidSigner(ms

Vulnerable code:
```\n        function claimSigner() public virtual {\n             if (signerCount == maxSigners) {\n                revert MaxSignersReached();\n        }\n        if (safe.isOwner(msg.sender)) {\n                revert SignerAlreadyClaimed(msg.sender);\n            }\n        if (!isValidSigner(msg.sender)) {\n             revert NotSignerHatWearer(msg.sender);\n         }\n         _grantSigner(msg.sender);\n           }\n```\n
HIGH severity: Vulnerable function: ```\nFile: TreasuryAction.sol\n    /// @notice redeems and transfers tokens to the treasury manager . ```\nFile: TreasuryAction.sol\n    /// @notice redeems and transfers tokens to the treasury manager contract\n    function _redeemAndTransfer(uint16 currencyId, int256 primeCashRedeemAmount) private returns (uint256) {\n        PrimeRate memory primeRate = PrimeRateLib.buildPrimeRateStateful(currenc

Vulnerable code:
```\nFile: TreasuryAction.sol\n    /// @notice redeems and transfers tokens to the treasury manager contract\n    function _redeemAndTransfer(uint16 currencyId, int256 primeCashRedeemAmount) private returns (uint256) {\n        PrimeRate memory primeRate = PrimeRateLib.buildPrimeRateStateful(currencyId);\n        int256 actualTransferExternal = TokenHandler.withdrawPrimeCash(\n            treasuryManagerContract,\n            currencyId,\n            primeCashRedeemAmount.neg(),\n            primeRate,\n            true // if ETH, transfers it as WETH\n        );\n\n        require(actualTransferExternal > 0);\n        return uint256(actualTransferExternal);\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n    function getLiquidationBonus(\n        address token,\n        uint256 borrowedAmount,\n   . ```\n    function getLiquidationBonus(\n        address token,\n        uint256 borrowedAmount,\n        uint256 times\n    ) public view returns (uint256 liquidationBonus) {\n        // Retrieve liquidation bonus for the given token\n        Liquidation memory liq = liquidationBonusForToken[token];

Vulnerable code:
```\n    function getLiquidationBonus(\n        address token,\n        uint256 borrowedAmount,\n        uint256 times\n    ) public view returns (uint256 liquidationBonus) {\n        // Retrieve liquidation bonus for the given token\n        Liquidation memory liq = liquidationBonusForToken[token];\n        unchecked {\n            if (liq.bonusBP == 0) {\n                // If there is no specific bonus for the token\n                // Use default bonus\n                liq.minBonusAmount = Constants.MINIMUM_AMOUNT;\n                liq.bonusBP = dafaultLiquidationBonusBP;\n            }\n            liquidationBonus = (borrowedAmount * liq.bonusBP) / Constants.BP;\n\n            if (liquidationBonus < liq.minBonusAmount) {\n                liquidationBonus = liq.minBonusAmount;\n            }\n            liquidationBonus *= (times > 0 ? times : 1);\n        }\n    }\n```\n
HIGH severity: Vulnerable function: ```\n1e6 * 1e18 / 100,001e18 = 0\n```\n. ```\n1e6 * 1e18 / 100,001e18 = 0\n```\n

Vulnerable code:
```\n1e6 * 1e18 / 100,001e18 = 0\n```\n
MEDIUM severity: Vulnerable function: ```\nDepositVault.sol\n    function deposit(uint256 amount, address tokenAddress) public payable {\n. ```\nDepositVault.sol\n    function deposit(uint256 amount, address tokenAddress) public payable {\n        require(amount > 0 || msg.value > 0, "Deposit amount must be greater than 0");\n        if(msg.value > 0) {\n            require(tokenAddress == address(0), "Token address must be 0x0 for ETH 

Vulnerable code:
```\nDepositVault.sol\n    function deposit(uint256 amount, address tokenAddress) public payable {\n        require(amount > 0 || msg.value > 0, "Deposit amount must be greater than 0");\n        if(msg.value > 0) {\n            require(tokenAddress == address(0), "Token address must be 0x0 for ETH deposits");\n            uint256 depositIndex = deposits.length;\n            deposits.push(Deposit(payable(msg.sender), msg.value, tokenAddress));\n            emit DepositMade(msg.sender, depositIndex, msg.value, tokenAddress);\n        } else {\n            require(tokenAddress != address(0), "Token address must not be 0x0 for token deposits");\n            IERC20 token = IERC20(tokenAddress);\n            token.safeTransferFrom(msg.sender, address(this), amount);\n            uint256 depositIndex = deposits.length;\n            deposits.push(Deposit(payable(msg.sender), amount, tokenAddress));//@audit-issue fee-on-transfer, rebalancing tokens will cause problems\n            emit DepositMade(msg.sender, depositIndex, amount, tokenAddress);\n        }\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction \_awardExternalErc721s(address winner) internal {\n  address currentToken = externalEr. ```\nfunction \_awardExternalErc721s(address winner) internal {\n  address currentToken = externalErc721s.start();\n  while (currentToken != address(0) && currentToken != externalErc721s.end()) {\n    uint256 balance = IERC721(currentToken).balanceOf(address(prizePool));\n    if (balance > 0) {\n   

Vulnerable code:
```\nfunction \_awardExternalErc721s(address winner) internal {\n  address currentToken = externalErc721s.start();\n  while (currentToken != address(0) && currentToken != externalErc721s.end()) {\n    uint256 balance = IERC721(currentToken).balanceOf(address(prizePool));\n    if (balance > 0) {\n      prizePool.awardExternalERC721(winner, currentToken, externalErc721TokenIds[currentToken]);\n      delete externalErc721TokenIds[currentToken];\n    }\n    currentToken = externalErc721s.next(currentToken);\n  }\n  externalErc721s.clearAll();\n}\n```\n
HIGH severity: Vulnerable function: ```\n    function zDeposit(address to) external payable onlyZauction {\n        ethbalance[to] = Saf. ```\n    function zDeposit(address to) external payable onlyZauction {\n        ethbalance[to] = SafeMath.add(ethbalance[to], msg.value);\n        emit zDeposited(to, msg.value);\n    }\n\n    function zWithdraw(address from, uint256 amount) external onlyZauction {\n        ethbalance[from] = SafeMa

Vulnerable code:
```\n    function zDeposit(address to) external payable onlyZauction {\n        ethbalance[to] = SafeMath.add(ethbalance[to], msg.value);\n        emit zDeposited(to, msg.value);\n    }\n\n    function zWithdraw(address from, uint256 amount) external onlyZauction {\n        ethbalance[from] = SafeMath.sub(ethbalance[from], amount);\n        emit zWithdrew(from, amount);\n    }\n```\n
HIGH severity: Vulnerable function: ```\nfunction _amountsForLiquidity(\n    int24 tickLower,\n    int24 tickUpper,\n    uint128 liquidi. ```\nfunction _amountsForLiquidity(\n    int24 tickLower,\n    int24 tickUpper,\n    uint128 liquidity\n) internal view returns (uint256, uint256) {\n    (uint160 sqrtRatioX96, , , , , , ) = IUniswapV3Pool(pool).slot0();\n    return\n        UV3Math.getAmountsForLiquidity(\n            sqrtRatioX96,

Vulnerable code:
```\nfunction _amountsForLiquidity(\n    int24 tickLower,\n    int24 tickUpper,\n    uint128 liquidity\n) internal view returns (uint256, uint256) {\n    (uint160 sqrtRatioX96, , , , , , ) = IUniswapV3Pool(pool).slot0();\n    return\n        UV3Math.getAmountsForLiquidity(\n            sqrtRatioX96,\n            UV3Math.getSqrtRatioAtTick(tickLower),\n            UV3Math.getSqrtRatioAtTick(tickUpper),\n            liquidity\n        );\n}\n```\n
HIGH severity: Vulnerable function: ```\n   function _beforeTokenTransfer(address from, address to, uint256) internal virtual override {. ```\n   function _beforeTokenTransfer(address from, address to, uint256) internal virtual override {\n        // Restrictions ignored for minting and burning\n        // If transferRestrictor is not set, no restrictions are applied\n\n        // @audit\n        // why don't you not apply mint and bu

Vulnerable code:
```\n   function _beforeTokenTransfer(address from, address to, uint256) internal virtual override {\n        // Restrictions ignored for minting and burning\n        // If transferRestrictor is not set, no restrictions are applied\n\n        // @audit\n        // why don't you not apply mint and burn in blacklist?\n        if (from == address(0) || to == address(0) || address(transferRestrictor) == address(0)) {\n            return;\n        }\n\n        // Check transfer restrictions\n        transferRestrictor.requireNotRestricted(from, to);\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\nif (ownerCount >= maxSigs) {\n    bool swapped = _swapSigner(owners, ownerC. ```\nif (ownerCount >= maxSigs) {\n    bool swapped = _swapSigner(owners, ownerCount, maxSigs, currentSignerCount, msg.sender);\n    if (!swapped) {\n        // if there are no invalid owners, we can't add a new signer, so we revert\n        revert NoInvalidSignersToReplace();\n    }\n}\n```\n

Vulnerable code:
```\nif (ownerCount >= maxSigs) {\n    bool swapped = _swapSigner(owners, ownerCount, maxSigs, currentSignerCount, msg.sender);\n    if (!swapped) {\n        // if there are no invalid owners, we can't add a new signer, so we revert\n        revert NoInvalidSignersToReplace();\n    }\n}\n```\n
HIGH severity: Vulnerable function: ```\n    if (tokens.length == 3) {\n        /// tokens[2] is WETH\n        uint2. ```\n    if (tokens.length == 3) {\n        /// tokens[2] is WETH\n        uint256 ethPrice = base.getPrice(tokens[2]);\n        return\n            (lpPrice(\n                virtualPrice,\n                base.getPrice(tokens[1]),\n                ethPrice,\n                base.getPrice(tokens[0]

Vulnerable code:
```\n    if (tokens.length == 3) {\n        /// tokens[2] is WETH\n        uint256 ethPrice = base.getPrice(tokens[2]);\n        return\n            (lpPrice(\n                virtualPrice,\n                base.getPrice(tokens[1]),\n                ethPrice,\n                base.getPrice(tokens[0])\n            ) * 1e18) / ethPrice;\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction getContractAddress(string memory \_contractName) private view returns (address) {\n   . ```\nfunction getContractAddress(string memory \_contractName) private view returns (address) {\n    return rocketStorage.getAddress(keccak256(abi.encodePacked("contract.address", \_contractName)));\n}\n```\n

Vulnerable code:
```\nfunction getContractAddress(string memory \_contractName) private view returns (address) {\n    return rocketStorage.getAddress(keccak256(abi.encodePacked("contract.address", \_contractName)));\n}\n```\n
HIGH severity: Vulnerable function: ```\nfunction _commitCollateral(\n    uint256 _bidId,\n    Collateral memory _collateralInfo\n) inte. ```\nfunction _commitCollateral(\n    uint256 _bidId,\n    Collateral memory _collateralInfo\n) internal virtual {\n    CollateralInfo storage collateral = _bidCollaterals[_bidId];\n    collateral.collateralAddresses.add(_collateralInfo._collateralAddress);\n    collateral.collateralInfo[\n        _

Vulnerable code:
```\nfunction _commitCollateral(\n    uint256 _bidId,\n    Collateral memory _collateralInfo\n) internal virtual {\n    CollateralInfo storage collateral = _bidCollaterals[_bidId];\n    collateral.collateralAddresses.add(_collateralInfo._collateralAddress);\n    collateral.collateralInfo[\n        _collateralInfo._collateralAddress\n    ] = _collateralInfo; <- @audit-issue collateral info overwritten\n    emit CollateralCommitted(\n        _bidId,\n        _collateralInfo._collateralType,\n        _collateralInfo._collateralAddress,\n        _collateralInfo._amount,\n        _collateralInfo._tokenId\n    );\n}\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction executeTransaction(uint256 transactionId)\n    public\n    notExecuted(transactionId)\. ```\nfunction executeTransaction(uint256 transactionId)\n    public\n    notExecuted(transactionId)\n    fullyConfirmed(transactionId)\n```\n

Vulnerable code:
```\nfunction executeTransaction(uint256 transactionId)\n    public\n    notExecuted(transactionId)\n    fullyConfirmed(transactionId)\n```\n
MEDIUM severity: Vulnerable function: ```\naddress internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2. ```\naddress internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n```\n

Vulnerable code:
```\naddress internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n```\n
MEDIUM severity: Vulnerable function: ```\n    if (tokens.length == 2) {\n        uint256[2] memory suppliedAmts;\n   . ```\n    if (tokens.length == 2) {\n        uint256[2] memory suppliedAmts;\n        for (uint256 i; i != 2; ++i) {\n            suppliedAmts[i] = IERC20Upgradeable(tokens[i]).balanceOf(\n                address(this)\n            );\n        }\n        ICurvePool(pool).add_liquidity(suppliedAmts, m

Vulnerable code:
```\n    if (tokens.length == 2) {\n        uint256[2] memory suppliedAmts;\n        for (uint256 i; i != 2; ++i) {\n            suppliedAmts[i] = IERC20Upgradeable(tokens[i]).balanceOf(\n                address(this)\n            );\n        }\n        ICurvePool(pool).add_liquidity(suppliedAmts, minLPMint);\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction initialize(\n address \_fujiadmin,\n address \_oracle,\n address \_collateralAsset,\n . ```\nfunction initialize(\n address \_fujiadmin,\n address \_oracle,\n address \_collateralAsset,\n address \_borrowAsset\n) external initializer {\n```\n

Vulnerable code:
```\nfunction initialize(\n address \_fujiadmin,\n address \_oracle,\n address \_collateralAsset,\n address \_borrowAsset\n) external initializer {\n```\n