Shrub contract 0x3b99…c256 on Ethereum

0x3b991130eae3cca364406d718da22fa1c3e7c256

As of 21 Nov 2026, Trustblock’s record holds 0x3b991130eae3cca364406d718da22fa1c3e7c256 on Ethereum as a contract of Shrub. 1 audit report on Trustblock lists this address: CertiK, 29 Nov 2024. 11 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 Ethereum.

AuditSecurity firmDateCommit named in the reportReport
Shrub tokenCertiKNot recorded (see the report)Open

Open and acknowledged findings in these reports11

1 High, 1 Medium, 9 Low. In the firm’s own words; statuses are the firm’s, from each report.

HighInitial Token DistributionShrub token · CertiKOpen

All of the `Shrub` tokens are sent to the contract deployer. This is a centralization risk because the deployer can distribute tokens without obtaining the consensus of the community. Any compromise to these addresses may allow a hacker to steal and sell tokens on the market, resulting in severe damage to the project. ### Onchain Analysis As of 11/29/2024, the top holders are listed below: | Address | Quantity | Percentage | | --- | --- | --- | | [0x000000000000000000000000000000000000dEaD](https://etherscan.io/address/0x000000000000000000000000000000000000dEaD) | 50,000,000 | 5.0000% | | [Uniswap V2: SHRUB](https://etherscan.io/address/0x6a63bE37A5501dC0f88ed3FA21d3cf9a64eB618e) | 17,264,403 | 1.7264% | | [pow.eth](https://etherscan.io/address/0xaf8DCE0CD3616767d728AC3cDA5E452963a8C758) | 16,433,174 | 1.6433% | | [0x796ecAC15D41384ebD4292deAb1Febf385F21e1d](https://etherscan.io/address/0x796ecAC15D41384ebD4292deAb1Febf385F21e1d) | 15,795,748 | 1.5796% | | [apu$taja.eth](0xF53cb2282f14FE029230aAA70c63B0f082B0bC4e) | 15,151,515 | 1.5152% | | [0xb44BaeA33299f99fA5f7F00757f983e64975b2C5](https://etherscan.io/address/0xb44BaeA33299f99fA5f7F00757f983e64975b2C5) | 14,835,502 | 1.4836% | | [0x3F24BBC1F32DDC6eF8595a70E7fA285A46810ecA](https://etherscan.io/address/0x3F24BBC1F32DDC6eF8595a70E7fA285A46810ecA) | 14,172,426 | 1.4172% | | [0xE52060793969D61f4b4C218eaD36F4d80b39bc9B](https://etherscan.io/address/0xE52060793969D61f4b4C218eaD36F4d80b39bc9B) | 12,607,075 | 1.2607% | | [0x9AF0c21B8CecF84DAD025b2Fb47f54446DF5D5F6](https://etherscan.io/address/0x9AF0c21B8CecF84DAD025b2Fb47f54446DF5D5F6) | 11,401,694 | 1.1402% | | [0x289Aa48798649b398150A2C5E92Cece34FA75DaF](https://etherscan.io/address/0x289Aa48798649b398150A2C5E92Cece34FA75DaF) | 10,000,000 | 1.0000% |

The audit on Trustblock · Open the report
MediumInadequate Blacklisting Mechanism for TransfersShrub token · CertiKAcknowledged

The function contains a flaw in its implementation where it is supposed to blacklist a particular address by marking it as true in a blacklist mapping. However, due to a logic error, the flag is incorrectly set to false, leading to the address not being blacklisted as intended when a disallowed transfer action is performed. ```solidity // anti bot logic if ( block.number <= (launchedAt + 0) && to != uniswapV2Pair && to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D) ) { @> _blacklist[to] = false; } ```

The audit on Trustblock · Open the report
LowCall Limit Of `enableTrading()`Shrub token · CertiKAcknowledged

The `enableTrading()` function is designed to be called by the owner to activate trading. However, this function can be invoked multiple times, with each invocation updating the `launchedAt` variable to the current `block.number`. This behavior may interfere with the proper functioning of the blacklist mechanism. ```solidity // once enabled, can never be turned off function enableTrading() external onlyOwner { tradingActive = true; swapEnabled = true; launchedAt = block.number; } ```

The audit on Trustblock · Open the report
LowConfirmation Of the Swap FunctionalityShrub token · CertiKAcknowledged

The deployed token contract includes a mechanism to swap tokens for ETH when specific conditions are satisfied. However, with fees set to 0 and ownership renounced, the swap operation is blocked by the following condition in the `swapBack()` function: ```solidity if (contractBalance == 0 || totalTokensToSwap == 0) { return; } ``` As a result, the contract currently holds approximately 7,823,630 tokens that cannot be swapped for ETH, leaving the tokens effectively stuck. Furthermore, approximately 4.464 ETH is also locked within the token contract.

The audit on Trustblock · Open the report
LowIncorrect Token Balance Management in `swapBack()Shrub token · CertiKAcknowledged

The `swapBack()` function has an issue with token balance management, which may lead to incorrect calculations during swap operations. Specifically, not all tokens are transferred, leaving `liquidityTokens` in the contract. Despite this, the internal counters `tokensForLiquidity`, `tokensForMarketing`, and `tokensForDev` are reset to zero, without accounting for the remaining `liquidityTokens`. This premature reset may result in incorrect token accounting if fees are recalibrated immediately afterward. Furthermore, the contract lacks a mechanism to add liquidity, even though `liquidityTokens` are calculated and exist within the function. This oversight indicates a missing implementation step for adding liquidity to the liquidity pool.

The audit on Trustblock · Open the report
LowLow-level Call UsageShrub token · CertiKAcknowledged

The smart contract contains low-level calls such as `call()`. Since these calls bypass some of the automatic checks that Solidity provides, like function type checks, they can introduce vulnerabilities, logic errors, or unexpected behavior. ```solidity=1540 (success, ) = address(devWallet).call{value: ethForDev}(""); ``` ```solidity=1542 (success, ) = address(marketingWallet).call{ value: address(this).balance }(""); ```

The audit on Trustblock · Open the report
LowMiscalculation of Max HoldingShrub token · CertiKAcknowledged

The transaction may be charged fees, so the max holding of the receiver should be the sum of the held tokens and the amount received from the transfer. The fees should not be included in the max holding. ```solidity=1421 require( amount + balanceOf(to) <= maxWallet, "Max wallet exceeded" ); ``` - Max holding is checked. ```solidity=1486 amount -= fees; ``` - Receiving amount is adjusted. ```solidity=483 _balances[recipient] = _balances[recipient].add(amount); ``` - Balance is increased by the adjusted amount.

The audit on Trustblock · Open the report
LowMissing Emit EventsShrub token · CertiKAcknowledged

There should always be events emitted in the sensitive functions that are controlled by centralization roles.

The audit on Trustblock · Open the report
LowMissing Zero Address ValidationShrub token · CertiKAcknowledged

Addresses are not validated before assignment or external calls, potentially allowing the use of zero addresses and leading to unexpected behavior or vulnerabilities. For example, transferring tokens to a zero address can result in a permanent loss of those tokens. ```solidity=1341 devWallet = newWallet; ``` - `newWallet` is not zero-checked before being used. ```solidity=1336 marketingWallet = newMarketingWallet; ``` - `newMarketingWallet` is not zero-checked before being used.

The audit on Trustblock · Open the report
LowPotential Sandwich AttacksShrub token · CertiKAcknowledged

A sandwich attack can occur when an attacker notices a transaction involving token swaps or liquidity additions that lacks slippage restrictions or minimum output amount settings. The attacker can exploit this by frontrunning the transaction to purchase one of the assets, thereby manipulating the exchange rate, and then backrunning the transaction to sell the asset for a profit. ```solidity=1499 uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, @> 0, // accept any amount of ETH path, address(this), block.timestamp ); ``` The referenced functions are invoked without setting slippage restrictions or minimum output amounts, making transactions that trigger these functions particularly vulnerable to sandwich attacks, especially when large input amounts are involved.

The audit on Trustblock · Open the report
LowUnused state variableShrub token · CertiKAcknowledged

Some state variables are not used in the codebase. This can lead to incomplete functionality or potential vulnerabilities if these variables are expected to be utilized. Variable `_holderFirstBuyTimestamp` in `Contract` is never used in `Contract`. ```solidity=1076 mapping(address => uint256) private _holderFirstBuyTimestamp; ``` ```solidity=1052 contract Contract is ERC20, Ownable { ```

The audit on Trustblock · Open the report

The Shrub security record · Every Shrub address · This address on the explorer