10k+

5k - 10k

1k - 5k

100 - 1k

0 - 100

<1 Month

1-3 Months

3-6 Months

6 Months -1 Year

1 -2 Years

2 -3 Years

> 3 Years

Sign Up for a Code Audit Today and Get 3 Months of Skynet for Free

MEXC

SpacePi

Tether

Baby Doge

DogeZilla

BabySwap 

FST SWAP

Radio Caca 

TiFi Token

CatCoin

Milo Inu

BNB Chain

Crypto.com

GemPad

Safemars

Shiba Inu

SpookyShiba 

Step

Guzzler

Axie Infinity

Metaverse VR 

SPY 

Ruby Play Network 

MetalSwap

A 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.

### External call(s)
File: Amazing.sol (Line 677, Function `Amazing._transfer`)
```solidity
                swapAndLiquify(contractTokenBalance);
```
* This function call executes the following external call(s).
* In `Amazing.addLiquidity`,
    * `uniswapV2Router.addLiquidityETH{value: ethAmount}(address(this),tokenAmount,0,0,owner(),block.timestamp)`
* In `Amazing.swapTokensForEth`,
    * `uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,0,path,address(this),block.timestamp)`
* In `Amazing.transferToAddressETH`,
    * `recipient.transfer(amount)`
* This call sends Ether.

### State variables written after the call(s)
File: Amazing.sol (Line 680, Function `Amazing._transfer`)
```solidity
            _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
```

File: Amazing.sol (Line 688, Function `Amazing._transfer`)
```solidity
            _balances[recipient] = _balances[recipient].add(finalAmount);
```

File: Amazing.sol (Line 682-683, Function `Amazing._transfer`)
```solidity
            uint256 finalAmount = (isExcludedFromFee[sender] || isExcludedFromFee[recipient]) ?
                                         amount : takeFee(sender, recipient, amount);
```
* This function call executes the following assignment(s).
* In `Amazing.takeFee`,
    * `_balances[address(this)] = _balances[address(this)].add(feeAmount)`



Potential Reentrancy Attack (Involving Ether)

In the contract `Amazing` the role `_owner` has authority over the functions shown in the diagram below.

![](https://accelerator-tasks-prod.s3.amazonaws.com/662a615104414e3fb4cb01e877345bc1/diagrams/centralization_Amazing__owner.svg)

---

In the contract `Ownable` the role `_owner` has authority over the functions shown in the diagram below.

![](https://accelerator-tasks-prod.s3.amazonaws.com/662a615104414e3fb4cb01e877345bc1/diagrams/centralization_Ownable__owner.svg)


Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and update the sensitive settings and execute sensitive functions of the project.

Centralization Risks in Amazing.sol

`1000000000000 * 10 ** 9` tokens were sent to the `owner` were sent to the contract when deploying the contract. 
This could be a centralization risk as the deployer can distribute tokens without obtaining the consensus of the community.

Initial Token Distribution

The `addLiquidity` function calls the `uniswapV2Router.addLiquidityETH` function with the `to` address specified as `owner` for acquiring the generated LP tokens from the pair. As a result, over time the `owner` address will accumulate a significant portion of LP tokens. If the `owner` is an EOA (Externally Owned Account), mishandling of its private key can have devastating consequences to the project as a whole.

Centralized Risk In `addLiquidity`

The `swapAndLiquify` function converts half of the amount tokens to BNB. The other half of tokens and part of the converted BNB are deposited into the pair on DEX as liquidity. For every `swapAndLiquify` function call, a small amount of BNB is leftover in the contract. This is because the price of tokens drops after swapping the first half of tokens into BNBs, and the other half of tokens require less than the converted BNB to be paired with it when adding liquidity. The contract doesn't appear to provide a way to withdraw those BNB, and they will be locked in the contract forever.

Contract gains non-withdrawable BNB via the `swapAndLiquify` function

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 back running (after the transaction being attacked) a transaction to sell the asset.

The following functions are called without setting restrictions on slippage or minimum output amount, so transactions triggering these functions are vulnerable to sandwich attacks, especially when the input amount is large:

- `uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens()`
- `uniswapV2Router.addLiquidityETH()`

Potential Sandwich Attacks

The contract is serving as the underlying entity to interact with third-party DEX. The scope of the audit would treat those 3rd party entities as black boxes and assume their functional correctness. However, in the real world, 3rd parties may be compromised and lead to assets being lost or stolen.

Third Party Dependencies

The above functions should revoke the privilege of the existing member.
For example:
- exclude from `isWalletLimitExempt`
- exclude from `isMarketPair`
- update existing router's allowance to 0

Privilege Revoke

The variables `_totalTaxIfBuying`,`_totalTaxIfSelling` and `_totalDistributionShares` should not exceed 100 respectively.

Lack of Input Validation

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

Missing Emit Events

`public` functions that are never called by the contract could be declared as `external`. `external` functions are more efficient than `public` functions.

Improper Usage of `public` and `external` Type

The linked variables could be declared as `constant` since these state variables are never modified.

Variables That Could Be Declared as `constant`

The contract contains unlocked compiler versions. An unlocked compiler version in the contract's source code 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 ambiguity when debugging as compiler-specific bugs may occur in the codebase that would be difficult to identify over a span of multiple compiler versions rather than a specific one.


Unlocked Compiler Version

There are many hardcode addresses in this codebase.

Hardcode Address

The linked variable declaration does not have a visibility specifier explicitly set.

Visibility Specifiers Missing

All variable types within Solidity are initialized to their default "empty" value, which is usually their zeroed out representation. Particularly:

- `uint` / `int`: All `uint` and `int` variable types are initialized at `0`
- `address`: All `address` types are initialized to `address(0)`
- `byte`: All `byte` types are initialized to their `byte(0)` representation
- `bool`: All `bool` types are initialized to `false`
- `ContractType`: All contract types (i.e. for a given `contract ERC20 {}` its contract type is `ERC20`) are initialized to their zeroed out address (i.e. for a given `contract ERC20 {}` its default value is `ERC20(address(0))`)
- `struct`: All `struct` types are initialized with all their members zeroed out according to this table

Redundant Variable Initialization

The function `swapAndLiquify` does not check the contract's current BNB balance before invoking the function `swapTokensForEth()`. In that case, the user can acquire exactly the amount of BNB that the
swap creates, and not make the liquidity event include any BNB that has been manually sent to the contract

Discussion For Function `swapTokensForEth()`

AmazingDoge

Amazing.sol

CertiK Skynet

Amazing Doge 

AmazingDoge🔶

RT @bscinstantly: 📢Hey #Memefam
🤩Let's take a look at the top meme gainers on #BNBChain in the last 24 Hours.
🤔Can they keep it going?
🎉🎉🎉…

RT @hc_capital: 🔥 Outstanding "Doge" Meme Projects

@dogecoin @BabyDogeCoin @DogelonMars @dogsofelon @dogebonk_token @amazingdogecoin @buff…

@cz_binance The sense of accomplishment after reading a book cannot be replaced by the Internet.

RT @HCGemAlerts: 🔥 Notable Meme Coins audited by @CertiK 

@BabyDogeCoin @Lovely_finance @Wakandainu @HogeFinance @CashCowProtocol @MicroPe…

RT @TyranoAnalytics: Outstanding "Doge" #Meme Projects

@BabyDogeCoin @dogecoin @dogebonk_token @DogelonMars @dogsofelon @dogey_inu @dogeca…

@cz_binance The rumor that CZ is traveling the world is true?

RT @Master_BNB: 🔥 @BNBCHAIN Meme Projects Audited By @CertiK 

@BabyDogeCoin @MarsDogeToken @MiloInu @HogeFinance @CashCowProtocol @ZeldaIn…

The third phase of limited NFT and joint NFT announced, 
the golden gift package has been greatly changed!  !  ! https://t.co/vLgsVepPin

RT @TyranoAnalytics: Top @BNBCHAIN Meme Projects Audited by @CertiK

@BabyDogeCoin @MarsDogeToken @MiloInu @HogeFinance @ZeldaInu @MemeNFTO…

@cz_binance Let's make Binance Chain great together

#	Wallet Address	Holding/Supply	Holding	Holding / Balance	Total Balance

1	0xc30211899ccb12...	53.7%	$137,120	50.03%	$274,090
2	Burn Address	24.4%	$61,369	0.00%	$0.00
3	Hot Wallet 15	5.7%	$14,417	0.03%	$48,263,952
4	0x407993575c91ce...	0.7%	$1,758	< 0.01%	$569,984,433,257
5	0x371cac6682567e...	0.3%	$842	1.41%	$59,758
6	0xa3e50cf05028ec...	0.3%	$842	1.41%	$59,759
7	0x59b3b114f8bb9c...	0.3%	$842	1.41%	$59,821
8	0x56e50d1138da84...	0.3%	$840	1.40%	$59,820
9	0xe4a58c3e2d74f5...	0.3%	$743	16.91%	$4,393
10	0xdcf682ee1ad5ec...	0.3%	$687	23.64%	$2,906

Amazing Doge

Highlights & Alerts

A Highly Centralized Project

Code Audit History

17

0

15

0

2

Skynet

Price Analysis

People Also...

Market Volatility & Liquidity

Token On-Chain Monitoring & Intelligence

Governance & Autonomy

Holder Cohort Daily Analysis(<$500)

Skynet Median Holder Distribution

Skynet Token Age Distribution