<username>{{ maskedUsername }}</username><space /><text>just voted for</text><space /><projectButton />

<username>{{ maskedUsername }}</username><space /><text>just voted for</text><space /><projectLogo /><space /><projectName>{{ projectName }}</projectName>

Bug Bounty rewards are grouped by severity and the impact of the vulnerability. Examples and descriptions of the type of vulnerabilities that correspond to each severity level can be found below. The payout amount has a 5 tier structure with separate scalesfor website/apps and smart contracts.

Description of vulnerability and your proof of concept or validation steps

Name

Please input a title

Short description of the vulnerability and the affected asset.

The core team is situated in country(ies) that received low aggregated ratings in terms of international judicial cooperation, criminal justice system, anti-money laundering, and corruption. This contextual data suggests an increased difficulty and complexity in preventing and mitigating fraud.

The core team is situated in country(ies) that received medium aggregated ratings in terms of international judicial cooperation, criminal justice system, anti-money laundering, and corruption. This contextual data suggests a medium level of geographic accountability, thus reducing and mitigating the risk of fraud.

The core team is situated in country(ies) that received the best aggregated ratings in terms of international judicial cooperation, criminal justice system, anti-money laundering, and corruption. This contextual data suggests the highest level of geographic accountability, thus maximizing the risk reduction and mitigation.

Vulnerability Title

Galactix Zone

transfer

transferFrom

totalSupply

balanceOf

allowance

approve

GalactixZoneToken

All of the `GalactixCoin` tokens are sent to the one externally-owned account (EOA) address.

```solidity=132
        _mint(_admin, _totalSupply);
```

And, there is a privileged function `batchAirdrop()` which allows the role `owner` to transfer any amount of `GXZ` tokens to any address in the batch.
```solidity=328
    function batchAirdrop(
        address[] memory _airdropAddresses,
        uint256[] memory _airdropAmounts
    ) external onlyOwner {
        if (_airdropAddresses.length != _airdropAmounts.length) {
            revert('Addresses and amounts must be equal length');
        }
        if (!locked) {
            _batchAirdrop(_airdropAddresses, _airdropAmounts);
        }
    }

    function _batchAirdrop(address[] memory _addresses, uint256[] memory _amounts)
        private
        lockFunction
    {
        uint256 senderBal = _balances[_msgSender()];
        uint256 totalSent = 0;
        uint256 arraySize = _addresses.length;

        for (uint256 i = 0; i < arraySize; ++i) {
            totalSent += _amounts[i];
            _balances[_addresses[i]] += _amounts[i];
            emit Transfer(_msgSender(), _addresses[i], _amounts[i]);
        }

        if (senderBal < totalSent) revert('Insufficient balance from airdrop instigator');
        uint256 newBalance = senderBal - totalSent;
        _balances[_msgSender()] = newBalance;
        emit AirDrop(_msgSender(), totalSent, arraySize);
    }
```

This is a centralization risk because the owner(s) of the EOAs can distribute tokens without obtaining the consensus of the community. Any compromise to the owner's account allows a hacker to steal and sell tokens on the market, resulting in severe damage to the project. 

Initial Distribution Centralization Risk

In the contract `GalactixZoneToken`, the role `owner()` has the authority to update the status of the `_requireNotPaused` function and further pause/resume the functionality of the `_transfer` function.

Any compromise to the private key of the `owner` may allow hackers to take advantage of this authority and allow/prevent external user access to the sensitive functionalities controlled by the `_requireNotPaused` function.


Pausing Centralization Risk

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

- `function setPause()`: Modifies the pause status of the contract. When the contract is paused, only addresses that are not the `owner()` and are added to the `isPauseExempt` mapping can transfer tokens to addresses that are not the `owner()`.
- `function updatePauseExempt()`: Adds or removes an address from the `isPauseExempt` mapping. Addresses in the `isPauseExempt` mapping are allowed to execute token transfers when the contract is paused.
- `function updateTaxExempt()`: Adds or removes an address from the `isTaxExempt` mapping. Only addresses in the `isTaxExempt` mapping can execute token transfers without paying taxes (common tax and owner tax) when transacting with **POOL** addresses.
- `function updateLiquidityPoolAddresses()`: Adds or removes an address from the `liquidityPoolAddresses` mapping. Addresses not in the `isTaxExempt` mapping need to pay taxes if they have token transfers with addresses in the `liquidityPoolAddresses` mapping.
- `function batchAirdrop()`: Allows the `owner()` role to send any amount of `GXZ` tokens in bulk to multiple addresses.
- `function setAntisnipeDisable()`: Disables the calling of third-party dependencies via the `IAntisnipe` interface.
- `function setAntisnipeAddress()`: Modifies the implementation of the third-party contract called via the `IAntisnipe` interface.
- `function setCommonTaxRate()`: Sets the tax rate for **COMMON TAX**.
- `function setOwnerTaxRate()`: Sets the tax rate for **OWNER TAX**.
- `function setCommonTaxRecipient()`: Sets the recipient address for **COMMON TAX**.
- `function setOwnerTaxRecipient()`: Sets the recipient address for **OWNER TAX**.

Any compromise to the `_owner` account may allow the hacker to take advantage of this authority.
![](https://accelerator-tasks-prod.s3.amazonaws.com/a62d54f4485d40c1b5b926b92d9b0af2/diagrams/centralization_GalaxticToken-GalactixZoneToken-_owner.svg)



Centralization Risks

`GalactixZoneToken` is an upgradeable contract, the owner can upgrade the contract without the community's commitment. If an attacker compromises the account, he can change the implementation of the contract and drain tokens from the contract.

Centralized Control of Contract Upgrade

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.

*This finding is considered minor because the state variable is only incremented or decremented. So, the effect of out-of-order increments may be unobservable after transaction. However, the reentrancy vulnerability may still cause other issues in the middle of transaction.*

### External call(s)
```solidity=148
                antisnipe.assureCanTransfer(msg.sender, from, to, amount);
```

### State variables written after the call(s)
```solidity=183
                _balances[from] -= (ownerTax + commonTax);
```

```solidity=188
                _balances[taxRecipient] += commonTax;
```

```solidity=196
                _balances[taxRecipient] += ownerTax;
```

*Note: Only a sample of 3 assignments (out of 4) are shown above.*



Potential Reentrancy Attack (Incrementing State)

In the `__GalactixToken__init_unchained()` function, state variables `commonTaxRate` and `ownerTaxRate` are set without value validation, there will be a risk that the value of these two state variables can be greater than `ONE_HUNDRED_PERCENT`.
```solidity=105
    function __GalactixToken__init_unchained(
        address _admin,
        uint256 _totalSupply,
        uint256 _commonTaxRate,
        uint256 _ownerTaxRate,
        address _commonTaxRecipient,
        address _ownerTaxRecipient,
        address[] memory _pauseExemptions,
        address[] memory _taxExemptions
    ) internal onlyInitializing {
        commonTaxRate = _commonTaxRate;
        ownerTaxRate = _ownerTaxRate;
```

And in functions `setCommonTaxRate()` and `setOwnerTaxRecipient()`, both of them have a `require` statement to protect the value of tax rate becoming greater than `ONE_HUNDRED_PERCENT(10,000)`, but tax rates are still able to be set with a very big value, e.g. 9999(tax rate 99%).
```solidity=379
    function setCommonTaxRate(uint256 _newTaxRate) external onlyOwner {
        require(_newTaxRate <= ONE_HUNDRED_PERCENT, 'GXZ: invalid tax rate!');
        commonTaxRate = _newTaxRate;
    }

    function setOwnerTaxRate(uint256 _newTaxRate) external onlyOwner {
        require(_newTaxRate <= ONE_HUNDRED_PERCENT, 'GXZ: invalid tax rate!');
        ownerTaxRate = _newTaxRate;
    }
```

Lack of Reasonable Fee Limitation

The cited address input is missing a check that it is not `address(0)`.

Missing Zero Address Validation

The 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=37
    IAntisnipe public antisnipe;
```
- The contract `GalactixZoneToken` interacts with third party contract with `IAntisnipe` interface via `antisnipe`.



Third-Party Dependency Usage

There is no storage gap preserved in the logic contract.

Any logic contract that acts as a base contract that needs to be inherited by other upgradeable children should have a reasonable size of storage gap preserved for the new state variable introduced by the future upgrades.

Lack of Storage Gap in Upgradeable Contract

Signed messages are not properly verified with the current **chain ID**, thus allowing attackers to perform replay attacks across chains. Hardcoded or cached chain ID values are also vulnerable since a hard fork may occur and change the chain ID in the future.

```solidity=15
        bytes32 messageHash = getMessageHash(_nonce, _salePhase, _signer, _candidate, _BUSDAmount);
        bytes32 ethSignedMessageHash = getEthSignedMessageHash(messageHash);
        address signerAddress = getSignerAddress(ethSignedMessageHash, _signature);
        return signerAddress == _signer;
```
- The library function `verifySignature()`, which eventually calls `ecrecover`. The **chain ID** is not used for creating a signed message hash.

```solidity=17
        address signerAddress = getSignerAddress(ethSignedMessageHash, _signature);
```
- Calling `getSignerAddress`, which eventually calls `ecrecover`.

```solidity=36
        return ECDSA.recover(_messageHash, _signature);
```
- Calling `ECDSA.recover()` with a hash that does not properly include the chain ID.



Potential Cross-Chain Replay Attack

One or more parameters with `memory` data location are never modified in their functions and those functions are never called internally within the contract. Thus, their data location can be changed to `calldata` to avoid the gas consumption copying from calldata to memory.

```solidity=56
    function initialize(
```
`initialize` has memory location parameters: `_pauseExemptions`, `_taxExemptions`.


Inefficient Memory Parameter

The smart contract does not check or store the return value of an external call in a local or state variable, which may introduce vulnerabilities due to the unhandled outcome.

```solidity=121
        isPauseExempt.add(_admin);
```


---
```solidity=122
        isTaxExempt.add(_admin);
```


---
```solidity=125
            isPauseExempt.add(_pauseExemptions[i]);
```


---
```solidity=129
            isTaxExempt.add(_taxExemptions[i]);
```



Unused Return Value

The smart contract contains one or more state changes related to arithmetic operations that do not emit events to communicate the changes outside the blockchain, which can lead to difficulties in tracking or verifying these changes and may affect the contract's transparency and auditability.
```solidity=293
        if (_isLPPool) {
            success = liquidityPoolAddresses.add(_lpPoolAddress);
        } else {
            success = liquidityPoolAddresses.remove(_lpPoolAddress);
        }

        if (!success) {
            revert('Address pool status is already set to this value.');
        }
```


---
```solidity=362
        antisnipeDisable = true;
```


---
```solidity=366
        antisnipe = IAntisnipe(addr);
```


---
```solidity=381
        commonTaxRate = _newTaxRate;
```


---
```solidity=386
        ownerTaxRate = _newTaxRate;
```



Leaderboards

Due Diligence Tools

Resources

Bug Bounty Program