0x698b1d54e936b9f772b8f58447194bbc82ec1933
As of 21 Nov 2026, Trustblock’s record holds 0x698b1d54e936b9f772b8f58447194bbc82ec1933 on Ethereum as a contract of Peezy Coin. 1 audit report on Trustblock lists this address: CertiK, 5 Feb 2025. 7 findings in it are recorded as open or acknowledged.
Each report’s scope as stored on Trustblock names this address on Ethereum.
| Audit | Security firm | Date | Commit named in the report | Report |
|---|---|---|---|---|
| Peezy - Audit | CertiK | Not recorded (see the report) | Open |
1 High, 1 Medium, 5 Low. In the firm’s own words; statuses are the firm’s, from each report.
All of the `PEEZY` 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.
The audit on Trustblock · Open the reportA 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. 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 reportThe `_transfer()` function in the contract is vulnerable to a denial-of-service (DoS) attack. The vulnerability arises from the `sellCount` mechanism, which limits the number of sell transactions to 3 per block. The `swapTokensForEth()` function swaps the minimum amount among `amount`, `contractTokenBalance`, and `_maxTaxSwap`, allowing an attacker to exploit the system by repeatedly initiating small token transfer amounts (e.g., 1 token) under certain situations. This attack can effectively block all other sell transactions within the same block. ```solidity=252 if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance > _taxSwapThreshold && _buyCount > _preventSwapBefore) { if (block.number > lastSellBlock) { sellCount = 0; } require(sellCount < 3, "Only 3 sells per block!"); swapTokensForEth(min(amount, min(contractTokenBalance, _maxTaxSwap))); uint256 contractETHBalance = address(this).balance; if (contractETHBalance > 0) { sendETHToFee(address(this).balance); } sellCount++; lastSellBlock = block.number; } ```
The audit on Trustblock · Open the reportThe maximum wallet limit `_maxWalletSize` could be bypassed through the `owner` address because of excluding the address from the check. The address `owner` can be used as the transit address to break the maximum wallet limit.
The audit on Trustblock · Open the reportThe 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=238 require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize."); ``` - Max holding is checked. ```solidity=268 _balances[to]=_balances[to].add(amount.sub(taxAmount)); ``` - Receiving amount is adjusted. ```solidity=268 _balances[to]=_balances[to].add(amount.sub(taxAmount)); ``` - Balance is increased by the adjusted amount.
The audit on Trustblock · Open the reportThe `PEEZY` contract is serving as the underlying entity to interact with third-party `uniswapV2Router`. The scope of the audit treats third-party entities as black boxes and assumes their functional correctness. However, in the real world, third parties can be compromised and this may lead to lost or stolen assets.
The audit on Trustblock · Open the reportIt is not recommended to use Solidity's `transfer()` and `send()` functions for transferring native tokens, 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. ```solidity=303 _taxWallet.transfer(amount); ``` - `PEEZY.sendETHToFee` uses `transfer()`.
The audit on Trustblock · Open the reportThe Peezy Coin security record · Every Peezy Coin address · This address on the explorer