0xec505c81d6a7567b5bde804870b1038832fe6da1
As of 21 Nov 2026, Trustblock’s record holds 0xec505c81d6a7567b5bde804870b1038832fe6da1 on Ethereum as a contract of Coinhound. 1 audit report on Trustblock lists this address: CertiK, 5 May 2023. 12 findings in it are recorded as open or acknowledged.
Each report’s scope as stored on Trustblock names this address on Ethereum.
3 High, 1 Medium, 8 Low. In the firm’s own words; statuses are the firm’s, from each report.
When the accumulated fees are swapped and liquidity is added to the pair, the LP token are minted to the `owner()`. If the `owner()` account is compromised, they can withdraw all the liquidity that has been added.
The audit on Trustblock · Open the report# Decentralization Efforts ## Description ### Ownable.sol In the contract `Ownable` 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 transfer or renounce ownership of the contract.  ### Coinhound.sol In the contract `Coinhound` 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 do the following: - set any address as an AMM pair charging any transfer interacting with the address buy or sell fees and removing the max wallet cap from the address; - send any ETH held by the contract to any address; - set the amount of tokens the contract needs to hold to swap them; - set the maximum amount of tokens that can be sent in a single transaction; - set the maximum amount of tokens per wallet; - set the developement wallet, which receives a portion of the ETH when the `CND` accumulated from fees is swapped; - set if swap and liquify is enabled; - exclude or un-exclude a wallet from the maximum wallet cap; - change the fees for buys, sells, and p2p; - exclude or un-exclude a wallet from fees; 
The audit on Trustblock · Open the reportIn the function `_transfer()`, the `liquidityPart` and `developmentPart` for ETH is calculated incorrectly. In addition, the calculations do not take into account the possibility of varying fees for buys, sells, and p2p.
The audit on Trustblock · Open the reportIf both the liquidity and development buy fee are set to zero and `swapAndLiquifyEnabled` is true, then when the contracts `CND` balance reaches the `swapTokensAtAmount` all sells will revert due to division by 0.
The audit on Trustblock · Open the reportIn the function `_transfer()`, the difference in the contracts ETH before and after the swap are not checked, causing any ETH that has accidentally been sent to the contract to be included in the distribution of fees.
The audit on Trustblock · Open the reportThe `amount` that is added to the balance of the `recipient` to check that it does not exceed the `maxTokenPerWallet` does not take into account the fees. If fee is taken on the transfer, then the amount transferred will be `amount - allFee` so that the transaction may fail stating that the `maxTokenPerWallet` was exceeded, when it will not be.
The audit on Trustblock · Open the reportThere should always be events emitted in the sensitive functions that are controlled by centralization roles. The following functions do not emit events: - `excludeFromFee()`; - `excludeFromMaxTokenPerWallet()`; - `migrateETH()`
The audit on Trustblock · Open the reportA reentrancy attack can occur when the contract creates a function that makes an external call to another untrusted contract before resolving any effects. If the attacker can control the untrusted contract, they can make a recursive call back to the original function, repeating interactions that would have otherwise not run after the external call resolved the effects. **We mark this as informational considering reentrancy is only possible if the development wallet is set as a contract that makes external calls** If the `developmentWallet` is set as a contract that makes an external call in its `fallback()` or `receive()` function, then when ether is transffered to the contract, the external call may be used in order to re-enter the contract. ### External call(s) ```solidity=221 payable(developmentWallet).transfer(developmentPart); ``` ### State variables written after the call(s) ```solidity=223 swapping = false; ``` ```solidity=228 super._transfer(sender, recipient, amount); ``` * This function call executes the following assignment(s). * In `ERC20._transfer`, * `_balances[from] = fromBalance - amount` * In `ERC20._transfer`, * `_balances[to] += amount` ```solidity=235 super._transfer(sender, address(this), allFee); ``` * This function call executes the following assignment(s). * In `ERC20._transfer`, * `_balances[from] = fromBalance - amount` * In `ERC20._transfer`, * `_balances[to] += amount` *Note: Only a sample of 3 assignments (out of 4) are shown above.*
The audit on Trustblock · Open the reportThe contract `Coinhound` uses an old solidity version. ```solidity=20 pragma solidity 0.8.2; ```
The audit on Trustblock · Open the reportLiterals with many digits are difficult to read and review. ```solidity=87 maxTokenPerWallet = 5000000 * (10 ** 18); ``` --- ```solidity=88 maxTokenPerTxn = 10000000 * (10 ** 18); ``` --- ```solidity=89 swapTokensAtAmount = 100000 * (10 ** 18); ``` --- ```solidity=94 _mint(msg.sender, 1000000000 * (10 ** 18)); ```
The audit on Trustblock · Open the reportIn the function `_transfer()` the following checks are performed: ```solidity require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); ``` However, it any case `super._transfer(sender, recipient, amount)` or `super._transfer(sender, recipient, amount - allFee)` will be called. The `_transfer()` function in Openzeppelin's `ERC20` contract preforms these checks making it unnecessary to check them again.
The audit on Trustblock · Open the reportIt is not recommended to use Solidity's `transfer()` and `send()` functions for transferring Ether, since some contracts may not be able to receive the funds. Those functions forward only a fixed amount of gas (2300 specifically) and the receiving contracts may run out of gas before finishing the transfer. Also, EVM instructions' gas costs may increase in the future. Thus, some contracts that can receive now may stop working in the future due to the gas limitation. The following lines use solidities `transfer()` function for transferring Ether. ```solidity=221 payable(developmentWallet).transfer(developmentPart); ``` ```solidity=277 recipient.transfer(address(this).balance); ```
The audit on Trustblock · Open the reportThe Coinhound security record · Every Coinhound address · This address on the explorer