Leaven Network contract 0x860e…42b9 on BNB Chain

0x860e3012a005eb30e634f3bc787a36a405ac42b9

As of 21 Nov 2026, Trustblock’s record holds 0x860e3012a005eb30e634f3bc787a36a405ac42b9 on BNB Chain as a contract of Leaven Network. 1 audit report on Trustblock lists this address: CertiK, 29 Sep 2022. 20 findings in it are recorded as open or acknowledged.

Audit reports that list this address1

Each report’s scope as stored on Trustblock names this address on BNB Chain.

AuditSecurity firmDateCommit named in the reportReport
Leaven Network - AuditCertiKNot recorded (see the report)Open

Open and acknowledged findings in these reports20

2 High, 18 Low. In the firm’s own words; statuses are the firm’s, from each report.

HighCentralization Risks in LeavenVaultV6Leaven Network - Audit · CertiKOpen

In the contract `LeavenVaultV6` the role `_owner` has authority over the functions shown in the diagram below. Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and modify contract parameters such as fees and strategies. ![](https://accelerator-tasks-prod.acc.corp.certik.com/3bd07f018fe64b9d99085ffb0742f12f/diagrams/centralization_LeavenVaultV6-LeavenVaultV6-_owner.svg) Furthermore, the role `_owner` has authority over the functions `transferOwnership()` and `renounceOwnership()`. Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and modify the `_owner` address. ![](https://accelerator-tasks-prod.acc.corp.certik.com/3bd07f018fe64b9d99085ffb0742f12f/diagrams/centralization_LeavenVaultV6-Ownable-_owner.svg)

The audit on Trustblock · Open the report
HighCentralization Risks in StrategyCakeBoostedLPLeaven Network - Audit · CertiKOpen

In the contract `StrategyCakeBoostedLP`, the role `_owner` has authority over the functions shown in the diagram below. Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and update several contract settings such as the fee recipient. ![](https://accelerator-tasks-prod.acc.corp.certik.com/8cc2cd66d61e4b29a36db56537d9fcac/diagrams/centralization_StrategyCakeBoostedLP-StratManager-_owner.svg) Furthermore, the role `_owner` has authority over the function `setBoostStaker()`. Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and configure the `BoostStaker`. Additionally, the role `_owner` has authority over the functions shown in the diagram below. Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and change the owner (`_owner` address) of the contract. ![](https://accelerator-tasks-prod.acc.corp.certik.com/8cc2cd66d61e4b29a36db56537d9fcac/diagrams/centralization_StrategyCakeBoostedLP-Ownable-_owner.svg) The role `keeper` has authority over the functions shown in the diagram below. Any compromise to the `keeper` account may allow the hacker to take advantage of this authority and pause or unpause the deposits and withdrawals and update other harvest parameters. ![](https://accelerator-tasks-prod.acc.corp.certik.com/8cc2cd66d61e4b29a36db56537d9fcac/diagrams/centralization_StrategyCakeBoostedLP-StrategyCakeBoostedLP-keeper.svg) Furthermore, the role `keeper` has authority over the functions shown in the diagram below. Any compromise to the `keeper` account may allow the hacker to take advantage of this authority and update fee settings. ![](https://accelerator-tasks-prod.acc.corp.certik.com/8cc2cd66d61e4b29a36db56537d9fcac/diagrams/centralization_StrategyCakeBoostedLP-FeeManager-keeper.svg) Additionally, the role `keeper` has authority over the function `setKeeper()`. Any compromise to the `keeper` account may allow the hacker to take advantage of this authority and update the `keeper` address. The role `strategist` has authority over the function `setStrategist()`. Any compromise to the `strategist` account may allow the hacker to take advantage of this authority and update the `strategist` address. Finally, the role `vault` has authority over the functions shown in the diagram below. Any compromise to the `vault` account may allow the hacker to take advantage of this authority and withdraw strategy funds. ![](https://accelerator-tasks-prod.acc.corp.certik.com/8cc2cd66d61e4b29a36db56537d9fcac/diagrams/centralization_StrategyCakeBoostedLP-StrategyCakeBoostedLP-vault.svg)

The audit on Trustblock · Open the report
LowDivide Before MultiplyLeaven Network - Audit · CertiKOpen

Performing integer division before multiplication truncates the low bits, losing the precision of calculation. ```solidity=1511 return _nativeBal.mul(45).div(1000).mul(callFee).div(MAX_FEE); ```

The audit on Trustblock · Open the report
LowHardcoded AddressLeaven Network - Audit · CertiKOpen

Hardcoded address may pose a centralization risk.

The audit on Trustblock · Open the report
LowLack of Natspec CommentsLeaven Network - Audit · CertiKOpen

Contract code is missing natspec comments, which helps understand the code and all the function's parameters. It also increases code readability which is always welcomed. Together with the lack of documentation and unit tests, it makes the whole project difficult to review.

The audit on Trustblock · Open the report
LowLeftover tokens caused by the unoptimized way toLeaven Network - Audit · CertiKOpen

The `addLiquidity()` function converts half of a tokens to another token. The other half of tokens and part of the converted tokens are deposited into the `lpToken0-lpToken1` pool as liquidity. For every `addLiquidity()` function call, a small amount of tokens could be leftover in the contract. This is because the price of the token drops after swapping the first half of one token into the other, and the other half of token require less than the converted token to be paired with it when adding liquidity.

The audit on Trustblock · Open the report
LowMissing Zero Address ValidationLeaven Network - Audit · CertiKOpen

Addresses should be checked before assignment or external call to make sure they are not zero addresses.

The audit on Trustblock · Open the report
LowOpenZeppelin Library Code Included in Source CodeLeaven Network - Audit · CertiKOpen

It is highly recommended NOT to include OpenZeppelin library code directly in source code, but import the original library to minimize risk because even slight changes to the library code may lead to critical/major vulnerabilities/bugs. For Solidity version 0.6.x, the latest OpenZeppelin version 3.4.2 should be used.

The audit on Trustblock · Open the report
LowPotential Sandwich AttacksLeaven Network - Audit · CertiKOpen

A sandwich attack might happen when an attacker observes a transaction swapping tokens or adding liquidity without setting restrictions on slippage or minimum output amount. The attacker can manipulate the exchange rate by frontrunning (before the transaction being attacked) a transaction to purchase one of the assets and make profits by backrunning (after the transaction being attacked) a transaction to sell the asset. The `swapExactTokensForTokens()` function is called without setting restrictions on slippage or minimum output amount, so transactions triggering this function are vulnerable to sandwich attacks, especially when the input amount is large.

The audit on Trustblock · Open the report
LowPull-Over-Push PatternLeaven Network - Audit · CertiKOpen

The change of `owner` by function `transferOwnership()` overrides the previously set `owner` with the new one without guaranteeing the new `owner` has the ability to actuate transactions on-chain. Furthermore, the `setKeeper()` and `setStrategist()` functions of the `StratManager` contract are also not requiring the new `keeper` or `strategist` addresses to accept the change.

The audit on Trustblock · Open the report
LowThird Party DependencyLeaven Network - Audit · CertiKOpen

The contract is serving as the underlying entity to interact with one or more third party protocols. The scope of the audit treats third party entities as black boxes and assume their functional correctness. However, in the real world, third parties can be compromised and this may lead to lost or stolen assets. In addition, upgrades of third parties can possibly create severe impacts, such as increasing fees of third parties, migrating to new LP pools, etc. ```solidity=1137 address public unirouter; ``` - The contract `StratManager` interacts with third party contract with `IUniswapRouterETH` interface via `unirouter`. --- ```solidity=1315 address public want; ``` - The contract `StrategyCakeBoostedLP` interacts with third party contract with `IUniswapV2Pair` interface via `want`. --- ```solidity=1320 address public boostStaker; ``` - The contract `StrategyCakeBoostedLP` interacts with third party contract with `IVeCakeStaker` interface via `boostStaker`. --- ```solidity=1323 address public chef; ``` - The contract `StrategyCakeBoostedLP` interacts with third party contract with `ICakeChefV2` interface via `chef`.

The audit on Trustblock · Open the report
LowToo Many DigitsLeaven Network - Audit · CertiKOpen

Literals with many digits are difficult to read and review.

The audit on Trustblock · Open the report
LowUnchecked ERC-20 `transfer()` CallLeaven Network - Audit · CertiKOpen

The return value of the ERC20 `transfer()` call is not checked. ```solidity=1536 IERC20(want).transfer(vault, wantBal); ```

The audit on Trustblock · Open the report
LowUninitialized Local VariableLeaven Network - Audit · CertiKOpen

- Local variable `_nativeBal` could be used before being initialized if `_outputBal` is 0: ```solidity=1504 uint256 _nativeBal; ```

The audit on Trustblock · Open the report
LowUnlocked Compiler VersionLeaven Network - Audit · CertiKOpen

The contract has unlocked compiler version. An unlocked compiler version in the source code of the contract permits the user to compile it at or above a particular version. This, in turn, leads to differences in the generated bytecode between compilations due to differing compiler version numbers. This can lead to an ambiguity when debugging as compiler specific bugs may occur in the codebase that would be hard to identify over a span of multiple compiler versions rather than a specific one. Additionally, it was found that multiple Solidity versions are used in the codebase.

The audit on Trustblock · Open the report
LowUnused InterfaceLeaven Network - Audit · CertiKOpen

```solidity=1118 interface IWrappedNative is IERC20 { ``` - `IWrappedNative` is declared but never used. --- ```solidity=1303 interface IGasPrice { ``` - `IGasPrice` is declared but never used.

The audit on Trustblock · Open the report
LowUnused Return ValueLeaven Network - Audit · CertiKOpen

The return value of an external call is not stored in a local or state variable. ```solidity=1447 IUniswapRouterETH(unirouter).swapExactTokensForTokens(toNative, 0, outputToNativeRoute, address(this), now); ``` --- ```solidity=1468 IUniswapRouterETH(unirouter).swapExactTokensForTokens(outputHalf, 0, outputToLp0Route, address(this), now); ``` --- ```solidity=1472 IUniswapRouterETH(unirouter).swapExactTokensForTokens(outputHalf, 0, outputToLp1Route, address(this), now); ``` --- ```solidity=1477 IUniswapRouterETH(unirouter).addLiquidity(lpToken0, lpToken1, lp0Bal, lp1Bal, 1, 1, address(this), now); ```

The audit on Trustblock · Open the report
LowUsage of `tx.origin`Leaven Network - Audit · CertiKOpen

Contracts that authorize accounts using the `tx.origin` variable are typically vulnerable to phishing attacks which can trick users into performing authenticated actions on the vulnerable contract. Besides the issue with authorization, there is a chance that `tx.origin` will be removed from the Ethereum protocol in the future, so code that uses `tx.origin` won't be compatible with future releases. For more information, see: https://consensys.github.io/smart-contract-best-practices/development-recommendations/solidity-specific/tx-origin/

The audit on Trustblock · Open the report
LowUsage of Magic NumberLeaven Network - Audit · CertiKOpen

The highlighted numbers are not clear enough. Defining them in constants would highly improve readability.

The audit on Trustblock · Open the report
LowVariables That Could Be Declared as ImmutableLeaven Network - Audit · CertiKOpen

The linked variables assigned in the constructor can be declared as `immutable`. Immutable state variables can be assigned during contract creation but will remain constant throughout the lifetime of a deployed contract. A big advantage of immutable variables is that reading them is significantly cheaper than reading from regular state variables since they will not be stored in storage.

The audit on Trustblock · Open the report

The Leaven Network security record · Every Leaven Network address · This address on the explorer