Peezy Coin contract 0x698b…1933 on Ethereum

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.

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
Peezy - AuditCertiKNot recorded (see the report)Open

Open and acknowledged findings in these reports7

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

HighInitial Token DistributionPeezy - Audit · CertiKOpen

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 report
MediumPotential Sandwich AttacksPeezy - Audit · 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. 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
Low`_transfer()` Function Vulnerable to DoS Attack oPeezy - Audit · CertiKAcknowledged

The `_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 report
LowMaximum Wallet Limit could be BypassedPeezy - Audit · CertiKAcknowledged

The 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 report
LowMiscalculation of Max HoldingPeezy - Audit · 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=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 report
LowThird-Party Dependency UsagePeezy - Audit · CertiKAcknowledged

The `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 report
LowUsage of `transfer`/`send` for Sending Native TokPeezy - Audit · CertiKAcknowledged

It 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 report

The Peezy Coin security record · Every Peezy Coin address · This address on the explorer