FreeCity

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.

One or more internal functions are not used. ```solidity=151 function ____Voice721_init_init_unchained( ``` --- ```solidity=164 function allOwner(uint256 parent, uint256 mother) ``` --- ```solidity=179 function _baseURI() internal view virtual override returns (string memory) { ``` --- ```solidity=13 function unsafeWriteBytes32(uint index, bytes32 source) ``` --- ```solidity=32 function unsafeWriteBytes(uint index, bytes memory source) ``` --- ```solidity=62 function unsafeWriteAddress(uint index, address source) ``` --- ```solidity=82 function unsafeWriteUint(uint index, uint source) ``` --- ```solidity=101 function unsafeWriteUint8(uint index, uint8 source) ``` --- ```solidity=122 function arrayEq(bytes memory a, bytes memory b) ``` --- ```solidity=270 function calculateMatchPrice(Order memory buy, Order memory sell) ```

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

The linked function is called `receiveApproval()`, however, the actual implementation of the function calls `transferFrom()`, which transfer's ERC20 tokens from one address to another. There is no guarantee the external implementation of `transferFrom()` will require approval in order to execute the function.

**require** can be used to check for conditions and throw an exception if the condition is not met. It is better to provide a string message containing details about the error that will be passed back to the caller.

Addresses should be checked before assignment or external call to make sure they are not zero addresses.

The following state variables never change and can be declared as `constant` to save gas: * `proxyRegistryAddress` * `delegateProxyImplementation`

The `SafeMath` library is used unnecessarily. With Solidity compiler versions 0.8.0 or newer, arithmetic operations will automatically revert in cases of integer overflow or underflow.

```solidity=6 abstract contract ERC20 is ERC20Basic { ``` - The abstract contract `ERC20` is declared but never implemented. --- ```solidity=5 abstract contract ERC721{ ``` - The abstract contract `ERC721` is declared but never implemented.

```solidity=89 event Mint(address indexed, address indexed, uint256); ``` - `Mint` is declared in `FreeCityGame_v2` but never emitted. --- ```solidity=92 event Find(address indexed, address indexed, uint256); ``` - `Find` is declared in `FreeCityGame_v2` but never emitted. --- ```solidity=14 event Approval( address indexed owner, address indexed spender, uint256 value ); ``` - `Approval` is declared in `ERC20` but never emitted. --- ```solidity=9 event Transfer(address indexed from, address indexed to, uint256 value); ``` - `Transfer` is declared in `ERC20Basic` but never emitted. --- ```solidity=9 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); ``` - `Transfer` is declared in `ERC721` but never emitted. --- ```solidity=14 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); ``` - `Approval` is declared in `ERC721` but never emitted. --- ```solidity=19 event ApprovalForAll(address indexed owner, address indexed operator, bool approved); ``` - `ApprovalForAll` is declared in `ERC721` but never emitted.