NUKE Token Logo

NUKE Token

About NUKE

Listings

Token 2 years
CoinGecko 2 years
CoinMarketCap 2 years

ABOUT NUKE WARS

Nuke Wars is an NFT-based play-to-earn game powered by radioactive deflation on the Binance Smart Chain.

In the Nuke Metaverse, both Nuketoken and NFTs burn according to the half-life principle, making holders increasingly wealthier over time. Such economic power is needed in the fight against the Evil Dumpers, who are seizing power throughout the galaxy. But fear not, for a mighty resistance has formed, giving rise to NFT troops armed with skills and weapons!

Now our heroine Nuke and the Good Forces are equipped with hundreds of thousands of NFTs and set out to recolonize the ancient planet of Mete Versa, marking the dawn of a new age.

The enemy may regroup and strike back with fury, but we are ready. We are the resistance! Join us, and we will make a stand and defeat the Evil Dumpers.

THE GAME

Your set of NFTs represents strength in battle and are used strategically. NFT troops can be upgraded to rarer, more valuable skills, weapons, and armor. The stronger you get, the higher your chances of winning battles, earning cash prizes and capturing land.

ACHIEVEMENTS

- Fair launch: $NUKE is in the hand of the many
- $NUKE is whale protected
- $NUKE has a dump defense
- NFT marketplace / GameFi is launched
- Play-to-earn in Episode 3

What Makes NUKE Unique?

In Nuke Wars, deflation is the name of the game. Nuclear girl Nuke comes from a planet where cryptographic tokens were invented a quadrillion years ago. Now Nuke demonstrates to Earthlings how to permanently burn the native token as well as NFTs directly in the AMM pool. With the first-ever half-life burn in Earth's crypto history, Nuke guarantees that the price of Nuketoken and the NFTs (that are bound to it) will rise forever.

Social

Laser Scorebeta Last Audit: 2 April 2022

report
Token seems to be (relatively) fine. It still become a scam, but probability is moderate.

Anti-Scam

Links


Unable to find manual contract audit (e.g. Certik, PeckShield, Solidity...)

BEP20._burn(address,uint256) (contracts/BEP20.sol#279-285) has costly operations inside a loop:
- _totalSupply = _totalSupply.sub(amount) (contracts/BEP20.sol#283)
Use a local variable to hold the loop computation result.

Additional information: link

Reentrancy in NUKE.decay() (contracts/NUKE.sol#56-66):
External calls:
- IPancakePair(pair).sync() (contracts/NUKE.sol#63)
State variables written after the call(s):
- decayLatest = block.timestamp (contracts/NUKE.sol#64)
Apply the check-effects-interactions pattern.

Additional information: link

NUKE._lock() (contracts/NUKE.sol#119-122) uses tx.origin for authorization: require(bool,string)(lock[tx.origin] < block.timestamp,lock) (contracts/NUKE.sol#120)
Do not use tx.origin for authorization.

Additional information: link

BEP20.constructor(string,string).name (contracts/BEP20.sol#58) shadows:
- BEP20.name() (contracts/BEP20.sol#74-76) (function)
- IBEP20.name() (@pancakeswap/pancake-swap-lib/contracts/token/BEP20/IBEP20.sol#24) (function)
BEP20.constructor(string,string).symbol (contracts/BEP20.sol#58) shadows:
- BEP20.symbol() (contracts/BEP20.sol#88-90) (function)
- IBEP20.symbol() (@pancakeswap/pancake-swap-lib/contracts/token/BEP20/IBEP20.sol#19) (function)
BEP20.allowance(address,address).owner (contracts/BEP20.sol#122) shadows:
- Ownable.owner() (@pancakeswap/pancake-swap-lib/contracts/access/Ownable.sol#36-38) (function)
BEP20._approve(address,address,uint256).owner (contracts/BEP20.sol#301) shadows:
- Ownable.owner() (@pancakeswap/pancake-swap-lib/contracts/access/Ownable.sol#36-38) (function)
NUKE.constructor(address,string,string,uint256,uint256,uint256)._name (contracts/NUKE.sol#30) shadows:
- BEP20._name (contracts/BEP20.sol#45) (state variable)
NUKE.constructor(address,string,string,uint256,uint256,uint256)._symbol (contracts/NUKE.sol#31) shadows:
- BEP20._symbol (contracts/BEP20.sol#46) (state variable)
Rename the local variables that shadow another component.

Additional information: link

NUKE.constructor(address,string,string,uint256,uint256,uint256)._factory (contracts/NUKE.sol#29) lacks a zero-check on :
- factory = _factory (contracts/NUKE.sol#36)
NUKE.setPair(address)._pair (contracts/NUKE.sol#81) lacks a zero-check on :
- pair = _pair (contracts/NUKE.sol#83)
Check that the address is not zero.

Additional information: link

Reentrancy in NUKE.decay() (contracts/NUKE.sol#56-66):
External calls:
- IPancakePair(pair).sync() (contracts/NUKE.sol#63)
State variables written after the call(s):
- _lock() (contracts/NUKE.sol#65)
- lock[tx.origin] = block.timestamp (contracts/NUKE.sol#121)
Apply the check-effects-interactions pattern.

Additional information: link

NUKE.devalue(address) (contracts/NUKE.sol#72-75) uses timestamp for comparisons
Dangerous comparisons:
- ! whitelist[holder] && balanceOf(holder) > _holdMax (contracts/NUKE.sol#74)
NUKE._afterTokenTransfer(address,address,uint256) (contracts/NUKE.sol#104-117) uses timestamp for comparisons
Dangerous comparisons:
- balanceOf(recipient) > _holdMax (contracts/NUKE.sol#107)
- require(bool,string)(sell[sender][day] <= totalSupply() / sellPerDayMaxRatio,sellPerDayMax) (contracts/NUKE.sol#112)
- balanceOf(recipient) > _holdMax && ! whitelist[recipient] (contracts/NUKE.sol#114)
NUKE._lock() (contracts/NUKE.sol#119-122) uses timestamp for comparisons
Dangerous comparisons:
- require(bool,string)(lock[tx.origin] < block.timestamp,lock) (contracts/NUKE.sol#120)
Avoid relying on block.timestamp.

Additional information: link

Address.isContract(address) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#26-37) uses assembly
- INLINE ASM (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#33-35)
Address._functionCallWithValue(address,bytes,uint256,string) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#134-160) uses assembly
- INLINE ASM (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#152-155)
Do not use evm assembly.

Additional information: link

Different versions of Solidity is used:
- Version used: ['>=0.4.0', '^0.6.2', '^0.6.6']
- >=0.4.0 (@pancakeswap/pancake-swap-lib/contracts/GSN/Context.sol#3)
- >=0.4.0 (@pancakeswap/pancake-swap-lib/contracts/access/Ownable.sol#3)
- >=0.4.0 (@pancakeswap/pancake-swap-lib/contracts/math/SafeMath.sol#3)
- >=0.4.0 (@pancakeswap/pancake-swap-lib/contracts/token/BEP20/IBEP20.sol#3)
- ^0.6.2 (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#3)
- ^0.6.6 (contracts/BEP20.sol#3)
- ^0.6.6 (contracts/NUKE.sol#2)
- ^0.6.6 (contracts/libraries/HalfLife.sol#2)
Use one Solidity version.

Additional information: link

Address._functionCallWithValue(address,bytes,uint256,string) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#134-160) is never used and should be removed
Address.functionCall(address,bytes) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#81-83) is never used and should be removed
Address.functionCall(address,bytes,string) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#91-97) is never used and should be removed
Address.functionCallWithValue(address,bytes,uint256) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#110-116) is never used and should be removed
Address.functionCallWithValue(address,bytes,uint256,string) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#124-132) is never used and should be removed
Address.isContract(address) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#26-37) is never used and should be removed
Address.sendValue(address,uint256) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#55-61) is never used and should be removed
BEP20._afterTokenTransfer(address,address,uint256) (contracts/BEP20.sol#217-219) is never used and should be removed
BEP20._burnFrom(address,uint256) (contracts/BEP20.sol#318-325) is never used and should be removed
Context._msgData() (@pancakeswap/pancake-swap-lib/contracts/GSN/Context.sol#24-27) is never used and should be removed
SafeMath.div(uint256,uint256) (@pancakeswap/pancake-swap-lib/contracts/math/SafeMath.sol#107-109) is never used and should be removed
SafeMath.div(uint256,uint256,string) (@pancakeswap/pancake-swap-lib/contracts/math/SafeMath.sol#123-133) is never used and should be removed
SafeMath.min(uint256,uint256) (@pancakeswap/pancake-swap-lib/contracts/math/SafeMath.sol#172-174) is never used and should be removed
SafeMath.mod(uint256,uint256) (@pancakeswap/pancake-swap-lib/contracts/math/SafeMath.sol#147-149) is never used and should be removed
SafeMath.mod(uint256,uint256,string) (@pancakeswap/pancake-swap-lib/contracts/math/SafeMath.sol#163-170) is never used and should be removed
SafeMath.mul(uint256,uint256) (@pancakeswap/pancake-swap-lib/contracts/math/SafeMath.sol#81-93) is never used and should be removed
SafeMath.sqrt(uint256) (@pancakeswap/pancake-swap-lib/contracts/math/SafeMath.sol#177-188) is never used and should be removed
Remove unused functions.

Additional information: link

Pragma version>=0.4.0 (@pancakeswap/pancake-swap-lib/contracts/GSN/Context.sol#3) allows old versions
Pragma version>=0.4.0 (@pancakeswap/pancake-swap-lib/contracts/access/Ownable.sol#3) allows old versions
Pragma version>=0.4.0 (@pancakeswap/pancake-swap-lib/contracts/math/SafeMath.sol#3) allows old versions
Pragma version>=0.4.0 (@pancakeswap/pancake-swap-lib/contracts/token/BEP20/IBEP20.sol#3) allows old versions
Pragma version^0.6.2 (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#3) allows old versions
Pragma version^0.6.6 (contracts/BEP20.sol#3) allows old versions
Pragma version^0.6.6 (contracts/NUKE.sol#2) allows old versions
Pragma version^0.6.6 (contracts/libraries/HalfLife.sol#2) allows old versions
solc-0.6.6 is not recommended for deployment
Deploy with any of the following Solidity versions: 0.5.16 - 0.5.17, 0.6.11 - 0.6.12, 0.7.5 - 0.7.6 Use a simple pragma version that allows any of these versions. Consider using the latest version of Solidity for testing.

Additional information: link

Low level call in Address.sendValue(address,uint256) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#55-61):
- (success) = recipient.call{value: amount}() (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#59)
Low level call in Address._functionCallWithValue(address,bytes,uint256,string) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#134-160):
- (success,returndata) = target.call{value: weiValue}(data) (@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol#143)
Avoid low-level calls. Check the call success. If the call is meant for a contract, check for code existence

Additional information: link

Parameter NUKE.setPair(address)._pair (contracts/NUKE.sol#81) is not in mixedCase
Parameter NUKE.setMaxRatios(uint256,uint256)._holdMaxRatio (contracts/NUKE.sol#92) is not in mixedCase
Parameter NUKE.setMaxRatios(uint256,uint256)._sellPerDayMaxRatio (contracts/NUKE.sol#92) is not in mixedCase
Function HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) is not in mixedCase
Constant HalfLife.MIN_64x64 (contracts/libraries/HalfLife.sol#6) is not in UPPER_CASE_WITH_UNDERSCORES
Constant HalfLife.MAX_64x64 (contracts/libraries/HalfLife.sol#7) is not in UPPER_CASE_WITH_UNDERSCORES
Constant HalfLife.N0i (contracts/libraries/HalfLife.sol#9) is not in UPPER_CASE_WITH_UNDERSCORES
Constant HalfLife.LN2i (contracts/libraries/HalfLife.sol#10) is not in UPPER_CASE_WITH_UNDERSCORES
Constant HalfLife.N0u (contracts/libraries/HalfLife.sol#11) is not in UPPER_CASE_WITH_UNDERSCORES
Follow the Solidity naming convention.

Additional information: link

Redundant expression "this (@pancakeswap/pancake-swap-lib/contracts/GSN/Context.sol#25)" inContext (@pancakeswap/pancake-swap-lib/contracts/GSN/Context.sol#15-28)
Remove redundant statements if they congest code but offer no value.

Additional information: link

Variable BEP20._totalSupply (contracts/BEP20.sol#43) is too similar to NUKE.constructor(address,string,string,uint256,uint256,uint256).totalSupply_ (contracts/NUKE.sol#32)
Prevent variables from having similar names.

Additional information: link

NUKE.slitherConstructorVariables() (contracts/NUKE.sol#11-124) uses literals with too many digits:
- holdMaxRatio = 1000000000 (contracts/NUKE.sol#18)
NUKE.slitherConstructorVariables() (contracts/NUKE.sol#11-124) uses literals with too many digits:
- sellPerDayMaxRatio = 10000000000 (contracts/NUKE.sol#19)
HalfLife.inv(int128) (contracts/libraries/HalfLife.sol#47-52) uses literals with too many digits:
- result = int256(0x100000000000000000000000000000000) / x (contracts/libraries/HalfLife.sol#49)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- require(bool)(x < 0x400000000000000000) (contracts/libraries/HalfLife.sol#55)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x < - 0x400000000000000000 (contracts/libraries/HalfLife.sol#57)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = 0x80000000000000000000000000000000 (contracts/libraries/HalfLife.sol#59)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x8000000000000000 > 0 (contracts/libraries/HalfLife.sol#61)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x4000000000000000 > 0 (contracts/libraries/HalfLife.sol#63)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x2000000000000000 > 0 (contracts/libraries/HalfLife.sol#65)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x1000000000000000 > 0 (contracts/libraries/HalfLife.sol#67)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x800000000000000 > 0 (contracts/libraries/HalfLife.sol#69)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x400000000000000 > 0 (contracts/libraries/HalfLife.sol#71)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x200000000000000 > 0 (contracts/libraries/HalfLife.sol#73)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x100000000000000 > 0 (contracts/libraries/HalfLife.sol#75)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x80000000000000 > 0 (contracts/libraries/HalfLife.sol#77)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x40000000000000 > 0 (contracts/libraries/HalfLife.sol#79)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x20000000000000 > 0 (contracts/libraries/HalfLife.sol#81)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x10000000000000 > 0 (contracts/libraries/HalfLife.sol#83)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x8000000000000 > 0 (contracts/libraries/HalfLife.sol#85)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x4000000000000 > 0 (contracts/libraries/HalfLife.sol#87)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x2000000000000 > 0 (contracts/libraries/HalfLife.sol#89)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x1000000000000 > 0 (contracts/libraries/HalfLife.sol#91)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x800000000000 > 0 (contracts/libraries/HalfLife.sol#93)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x400000000000 > 0 (contracts/libraries/HalfLife.sol#95)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x200000000000 > 0 (contracts/libraries/HalfLife.sol#97)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x100000000000 > 0 (contracts/libraries/HalfLife.sol#99)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128 (contracts/libraries/HalfLife.sol#100)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x80000000000 > 0 (contracts/libraries/HalfLife.sol#101)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128 (contracts/libraries/HalfLife.sol#102)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x40000000000 > 0 (contracts/libraries/HalfLife.sol#103)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128 (contracts/libraries/HalfLife.sol#104)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x20000000000 > 0 (contracts/libraries/HalfLife.sol#105)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128 (contracts/libraries/HalfLife.sol#106)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x10000000000 > 0 (contracts/libraries/HalfLife.sol#107)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128 (contracts/libraries/HalfLife.sol#108)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x8000000000 > 0 (contracts/libraries/HalfLife.sol#109)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128 (contracts/libraries/HalfLife.sol#110)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x4000000000 > 0 (contracts/libraries/HalfLife.sol#111)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128 (contracts/libraries/HalfLife.sol#112)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x2000000000 > 0 (contracts/libraries/HalfLife.sol#113)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128 (contracts/libraries/HalfLife.sol#114)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x1000000000 > 0 (contracts/libraries/HalfLife.sol#115)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128 (contracts/libraries/HalfLife.sol#116)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x800000000 > 0 (contracts/libraries/HalfLife.sol#117)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128 (contracts/libraries/HalfLife.sol#118)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x400000000 > 0 (contracts/libraries/HalfLife.sol#119)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128 (contracts/libraries/HalfLife.sol#120)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x200000000 > 0 (contracts/libraries/HalfLife.sol#121)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128 (contracts/libraries/HalfLife.sol#122)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x100000000 > 0 (contracts/libraries/HalfLife.sol#123)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128 (contracts/libraries/HalfLife.sol#124)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x80000000 > 0 (contracts/libraries/HalfLife.sol#125)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128 (contracts/libraries/HalfLife.sol#126)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x40000000 > 0 (contracts/libraries/HalfLife.sol#127)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128 (contracts/libraries/HalfLife.sol#128)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x20000000 > 0 (contracts/libraries/HalfLife.sol#129)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128 (contracts/libraries/HalfLife.sol#130)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x10000000 > 0 (contracts/libraries/HalfLife.sol#131)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128 (contracts/libraries/HalfLife.sol#132)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x8000000 > 0 (contracts/libraries/HalfLife.sol#133)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128 (contracts/libraries/HalfLife.sol#134)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x4000000 > 0 (contracts/libraries/HalfLife.sol#135)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128 (contracts/libraries/HalfLife.sol#136)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x2000000 > 0 (contracts/libraries/HalfLife.sol#137)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128 (contracts/libraries/HalfLife.sol#138)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x1000000 > 0 (contracts/libraries/HalfLife.sol#139)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128 (contracts/libraries/HalfLife.sol#140)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x800000 > 0 (contracts/libraries/HalfLife.sol#141)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128 (contracts/libraries/HalfLife.sol#142)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x400000 > 0 (contracts/libraries/HalfLife.sol#143)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000000002C5C85FDF477B662B26945 >> 128 (contracts/libraries/HalfLife.sol#144)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x200000 > 0 (contracts/libraries/HalfLife.sol#145)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000000162E42FEFA3AE53369388C >> 128 (contracts/libraries/HalfLife.sol#146)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- x & 0x100000 > 0 (contracts/libraries/HalfLife.sol#147)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000000000B17217F7D1D351A389D40 >> 128 (contracts/libraries/HalfLife.sol#148)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128 (contracts/libraries/HalfLife.sol#150)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128 (contracts/libraries/HalfLife.sol#152)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128 (contracts/libraries/HalfLife.sol#154)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128 (contracts/libraries/HalfLife.sol#156)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128 (contracts/libraries/HalfLife.sol#158)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128 (contracts/libraries/HalfLife.sol#160)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000000000162E42FEFA39F02B772C >> 128 (contracts/libraries/HalfLife.sol#162)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128 (contracts/libraries/HalfLife.sol#164)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128 (contracts/libraries/HalfLife.sol#166)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000000000002C5C85FDF473DEA871F >> 128 (contracts/libraries/HalfLife.sol#168)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128 (contracts/libraries/HalfLife.sol#170)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000000000000B17217F7D1CF79E949 >> 128 (contracts/libraries/HalfLife.sol#172)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128 (contracts/libraries/HalfLife.sol#174)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128 (contracts/libraries/HalfLife.sol#176)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000000000000162E42FEFA39EF366F >> 128 (contracts/libraries/HalfLife.sol#178)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128 (contracts/libraries/HalfLife.sol#180)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128 (contracts/libraries/HalfLife.sol#182)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128 (contracts/libraries/HalfLife.sol#184)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x1000000000000000162E42FEFA39EF358 >> 128 (contracts/libraries/HalfLife.sol#186)
HalfLife.exp_2(int128) (contracts/libraries/HalfLife.sol#54-195) uses literals with too many digits:
- result = result * 0x10000000000000000B17217F7D1CF79AB >> 128 (contracts/libraries/HalfLife.sol#188)
HalfLife.exp(int128) (contracts/libraries/HalfLife.sol#197-204) uses literals with too many digits:
- require(bool)(x < 0x400000000000000000) (contracts/libraries/HalfLife.sol#198)
HalfLife.exp(int128) (contracts/libraries/HalfLife.sol#197-204) uses literals with too many digits:
- x < - 0x400000000000000000 (contracts/libraries/HalfLife.sol#200)
HalfLife.slitherConstructorConstantVariables() (contracts/libraries/HalfLife.sol#4-210) uses literals with too many digits:
- MIN_64x64 = - 0x80000000000000000000000000000000 (contracts/libraries/HalfLife.sol#6)
HalfLife.slitherConstructorConstantVariables() (contracts/libraries/HalfLife.sol#4-210) uses literals with too many digits:
- N0i = 18446744073709551616000000000000000000 (contracts/libraries/HalfLife.sol#9)
Use: Ether suffix, Time suffix, or The scientific notation

Additional information: link

renounceOwnership() should be declared external:
- Ownable.renounceOwnership() (@pancakeswap/pancake-swap-lib/contracts/access/Ownable.sol#55-58)
transferOwnership(address) should be declared external:
- Ownable.transferOwnership(address) (@pancakeswap/pancake-swap-lib/contracts/access/Ownable.sol#64-66)
name() should be declared external:
- BEP20.name() (contracts/BEP20.sol#74-76)
decimals() should be declared external:
- BEP20.decimals() (contracts/BEP20.sol#81-83)
symbol() should be declared external:
- BEP20.symbol() (contracts/BEP20.sol#88-90)
transfer(address,uint256) should be declared external:
- BEP20.transfer(address,uint256) (contracts/BEP20.sol#114-117)
allowance(address,address) should be declared external:
- BEP20.allowance(address,address) (contracts/BEP20.sol#122-124)
approve(address,uint256) should be declared external:
- BEP20.approve(address,uint256) (contracts/BEP20.sol#133-136)
transferFrom(address,address,uint256) should be declared external:
- BEP20.transferFrom(address,address,uint256) (contracts/BEP20.sol#150-162)
increaseAllowance(address,uint256) should be declared external:
- BEP20.increaseAllowance(address,uint256) (contracts/BEP20.sol#176-179)
decreaseAllowance(address,uint256) should be declared external:
- BEP20.decreaseAllowance(address,uint256) (contracts/BEP20.sol#195-202)
mint(uint256) should be declared external:
- BEP20.mint(uint256) (contracts/BEP20.sol#212-215)
holdMax() should be declared external:
- NUKE.holdMax() (contracts/NUKE.sol#48-50)
sellPerDayMax() should be declared external:
- NUKE.sellPerDayMax() (contracts/NUKE.sol#52-54)
Use the external attribute for functions never called from the contract.

Additional information: link

Holders:


Token is deployed only at one blockchain


Twitter account link seems to be invalid


Unable to find Blog account (Reddit or Medium)


Unable to find Youtube account


Unable to find token/project description on the website or on BscScan, CoinMarketCap


Unable to find token contract audit


Unable to find audit link on the website


Unable to find whitepaper link on the website


Unable to find token on CoinHunt

Additional information: link


Unable to find code repository for the project


Token has a considerable age, but social accounts / website are missing or have few users


Young tokens have high risks of price dump / death


Young tokens have high risks of price dump / death


Token has relatively low CoinMarketCap rank

Price for NUKE