0x53d8ed82aa74ced7665d87803e0ee2f5436ace68
As of 21 Nov 2026, Trustblock’s record holds 0x53d8ed82aa74ced7665d87803e0ee2f5436ace68 on Ethereum as a contract of MoveMoveCoin. 1 audit report on Trustblock lists this address: CertiK, 26 Apr 2024. 9 findings in it are recorded as open or acknowledged.
Each report’s scope as stored on Trustblock names this address on Ethereum.
3 High, 3 Medium, 3 Low. In the firm’s own words; statuses are the firm’s, from each report.
In the contract `Ownable` (which is inherited by `MMCNFT`) 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 the ownership.  ----- In the contract `MMCNFT` 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 set `uniswapPair`, uri, mint tokens, transfer NFT tokens out from the contract, transfer ERC20 tokens in the contract, add liquidity, and remove liquidity.  ----- In the contract `BlackList` 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 add/remove a user from the blacklist and transfer the balance from a blacklisted user to the `owner`.  In the contract `MMCoin` 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 lock a user's balance, deprecate the contract, mint tokens, burn tokens, and set the fee rate.  In the contract `Ownable` (which is inherited by `MMCoin`) the role `owner` has authority over the function shown in the diagram below. Any compromise to the `owner` account may allow the hacker to take advantage of this authority and transfer the ownership.  In the contract `Pausable` 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 pause/unpause token transfers. 
The audit on Trustblock · Open the reportIn the contracts `MMCoin` and `MMCNFT`, the role owner has the authority to mint tokens to an arbitrary account without sanity restriction. In the contract `BlackList`, which is inherited by `MMCoin`, the role owner has the authority to add an arbitrary account to the blacklist and set its balance to 0. Any compromise to the owner account may allow a hacker to take advantage of this authority and manipulate users' balances. The hacker could also update his/her balance to a large number, sell these tokens, and cause the token price to drop.
The audit on Trustblock · Open the reportThe contract features a deprecation mechanism controlled by the contract owner, allowing redirection of key functions such as `transfer()`, `transferFrom()`, `approve()`, and `balanceOf()` to an `upgradedAddress`. This approach introduces risks akin to those found in upgradeable contracts. If the owner's account is compromised, an attacker could potentially redirect these functions to a malicious contract, enabling inappropriate actions that could compromise user balances or manipulate contract behavior.
The audit on Trustblock · Open the reportThe data type of the `decimals` state variable should be `uint8` to conform to the EIP-20 standard, as many smart contract interacting with ERC-20 tokens will result in a fail.
The audit on Trustblock · Open the reportThe smart contract contains incorrect return values for ERC-20 functions. For example, if the `transfer` function does not return a bool value, contracts compiled with Solidity versions > 0.4.22 interacting with the function will fail to execute, as the required return value is missing. ```solidity=81 function transfer(address to, uint value) public; ``` --- ```solidity=91 function transferFrom(address from, address to, uint value) public; ``` --- ```solidity=92 function approve(address spender, uint value) public; ``` --- ```solidity=122 function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) { ``` --- ```solidity=167 function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) { ``` --- ```solidity=195 function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) { ``` --- ```solidity=380 function transfer(address _to, uint _value) public whenNotPaused { ``` --- ```solidity=434 function transferFrom(address _from, address _to, uint _value) public whenNotPaused { ``` --- ```solidity=469 function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) { ```
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. For example, if an attacker controls the untrusted contract and receives a minted token, they can initiate calls to any contract before the tokenURI is set. --- ### External call(s) ```solidity=146 _mint(account, id, amount, data); // minting tokens ``` * This function call executes the following external call(s). * In `ERC1155._doSafeBatchTransferAcceptanceCheck`, * `response = IERC1155Receiver(to).onERC1155BatchReceived(operator,from,ids,values,data)` * In `ERC1155._doSafeTransferAcceptanceCheck`, * `response = IERC1155Receiver(to).onERC1155Received(operator,from,id,value,data)` ### State variables written after the call(s) ```solidity=147 _tokenURIs[id] = tokenUri; ``` --- ### External call(s) ```solidity=153 _mintBatch(to, ids, amounts, data); // Minting tokens in batches ``` * This function call executes the following external call(s). * In `ERC1155._doSafeBatchTransferAcceptanceCheck`, * `response = IERC1155Receiver(to).onERC1155BatchReceived(operator,from,ids,values,data)` * In `ERC1155._doSafeTransferAcceptanceCheck`, * `response = IERC1155Receiver(to).onERC1155Received(operator,from,id,value,data)` ### State variables written after the call(s) ```solidity=155 _tokenURIs[ids[i]] = tokenUris[i]; ```
The audit on Trustblock · Open the reportThe `MMCNFT` contract includes a `receive()` function enabling it to accept Ether directly through transactions. However, there is no corresponding function to withdraw ETH from the contract. This oversight could result in ETH becoming permanently locked within the contract.
The audit on Trustblock · Open the reportThe `transfer()` and `transferFrom()` functions in the contract do not include checks to prevent tokens from being transferred to the zero address (`address(0)`) or the contract's own address (`address(this)`). This absence of validation can lead to unintentional token loss if users mistakenly set the destination address to either of these addresses, effectively burning the tokens or locking them within the contract with no recovery option.
The audit on Trustblock · Open the reportThe contract is serving as the underlying entity to interact with one or more third party protocols. 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. In addition, upgrades of third parties can possibly create severe impacts, such as increasing fees of third parties, migrating to new LP pools, etc. ```solidity=21 address public uniswapPair; ``` - The contract `MMCNFT` interacts with third party contract with `IERC20` interface via `uniswapPair`. --- ```solidity=22 IUniswapV2Router02 public uniswapV2Router; ``` - The contract `MMCNFT` interacts with third party contract with `IUniswapV2Router02` interface via `uniswapV2Router`. --- ```solidity=23 IUniswapV2Factory public uniswapV2Factory; ``` - The contract `MMCNFT` interacts with third party contract with `IUniswapV2Factory` interface via `uniswapV2Factory`. --- ```solidity=49 function uniAddLiquidity(address _tokenA, address _tokenB, uint256 _amountA, uint256 _amountB) external onlyOwner { ``` - The function `MMCNFT.uniAddLiquidity` interacts with third party contract with `IERC20` interface via `_tokenA`. --- ```solidity=49 function uniAddLiquidity(address _tokenA, address _tokenB, uint256 _amountA, uint256 _amountB) external onlyOwner { ``` - The function `MMCNFT.uniAddLiquidity` interacts with third party contract with `IERC20` interface via `_tokenB`.
The audit on Trustblock · Open the reportThe MoveMoveCoin security record · Every MoveMoveCoin address · This address on the explorer