CloudTx contract 0xffad…def2 on BNB Chain

0xffad7f9f704a5fdc6265e24b436b4b35ed52def2

As of 21 Nov 2026, Trustblock’s record holds 0xffad7f9f704a5fdc6265e24b436b4b35ed52def2 on BNB Chain as a contract of CloudTx. 1 audit report on Trustblock lists this address: CertiK, 1 May 2023. 14 findings in it are recorded as open or acknowledged.

Audit reports that list this address1

Each report’s scope as stored on Trustblock names this address on BNB Chain.

AuditSecurity firmDateCommit named in the reportReport
Cloudtx FinanceCertiKNot recorded (see the report)Open

Open and acknowledged findings in these reports14

2 High, 1 Medium, 11 Low. In the firm’s own words; statuses are the firm’s, from each report.

HighCentralization Related RisksCloudtx Finance · CertiKAcknowledged

The role `owner` in `CloudTx` contract has authority over the following functions; - `renounceOwnership()`: Transfer the contract ownership to zero address; - `transferOwnership()`: Transfer the contract ownership to an arbitrary EOA; - `excludeFromFee()`: Exempt an arbitrary EOA from paying transaction fees; - `includeInFee()`: Include an arbitrary EOA to pay transaction fees; - `_set_Fees()`: Set the amount of `Buy_Fee` and `Sell_Fee`; - `Wallet_Update_Dev()`: Set the address of `Wallet_Dev` to an arbitrary EOA; - `set_Swap_And_Liquify_Enabled()`: Enable/disable swap and liquify; - `set_Number_Of_Transactions_Before_Liquify_Trigger()`: Set the number of transactions required for performing one time of swap and liquify; - `blacklist_Add_Wallets()`: Blacklist an EOA from transferring the tokens; - `blacklist_Remove_Wallets()`: Remove an EOA from the blacklist; - `blacklist_Switch()`: Enable/Disable the blacklist function; - `set_Transfers_Without_Fees()`: Enable/Disable the transaction fee on transfer between non-DEX EOAs; - `set_Max_Transaction_Percent()`: Set the max transferring amount percentage of total supply in one transaction; - `set_Max_Wallet_Percent()`: Set the max amount of tokens an EOA can hold; - `process_Tokens_Now()`: Swap and liquify the token owned by the contract immediately; - `remove_Random_Tokens()`: Rescue function to remove tokens owned by the contract; - `set_New_Router_and_Make_Pair()`: Set the new router address and create a pair of `CloudTx` and `BNB`; - `set_New_Router_Address()`: Set the new router address; - `set_New_Pair_Address()`: Set the new pair address; Any compromise to the `owner` account may allow a hacker to take advantage of this authority and manipulate the program settings, even withdraw ERC20 tokens and BNB from the contract.

The audit on Trustblock · Open the report
HighInitial Token DistributionCloudtx Finance · CertiKAcknowledged

All **CloudTx** tokens are sent to the contract deployer when deploying the contract. This is a potential centralization risk as the deployer can distribute **CloudTx** tokens without the consensus of the community.

The audit on Trustblock · Open the report
MediumShadowing on `_TotalFee`Cloudtx Finance · CertiKAcknowledged

In the initial fee settings, the `_TotalFee` equals to the `_buyFee` + `_sellFee`: ```solidity=410 uint256 private _TotalFee = 20; uint256 public _buyFee = 10; uint256 public _sellFee = 10; ``` The `_TotalFee` is shadowing in the transfer process, which means it will be updated each time during the swap. ```solidity=821 } else if (from == uniswapV2Pair){_TotalFee = _buyFee;} else if (to == uniswapV2Pair){_TotalFee = _sellFee;} ``` When both `from` and `to` are not excluded and not `uniswapV2Pair`, the fee is supposed to be `_buyFee` + `_sellFee`, but currently, it will become the buy fee or sell fee solely after the first swap.

The audit on Trustblock · Open the report
LowImproper Update For Router AddressCloudtx Finance · CertiKOpen

The ` set_New_Router_and_Make_Pair()` function does not check if the pair has been created. If the pair has already been created, then calling `createPair()` on the factory contract will always cause this function to revert, making it impossible to update the router to this address.

The audit on Trustblock · Open the report
LowInvalid `percent_Of_Tokens_To_Process` updateCloudtx Finance · CertiKOpen

When `process_Tokens_Now`, the contract owner may select the percent of the `cloudTx` token holding in the contract to swap. When the input amount `percent_Of_Tokens_To_Process` is larger than 100, the value `percent_Of_Tokens_To_Process` will be modified to 100 to avoid unexpected failure due to insufficient tokens. However, the current assignment statement uses "==" for the assignment which will be invalid. ```solidity=852 if (percent_Of_Tokens_To_Process > 100){percent_Of_Tokens_To_Process == 100;} ```

The audit on Trustblock · Open the report
LowMiscalculation of Max HoldingCloudtx Finance · CertiKOpen

The transaction may be charged fees, so the max holding of the receiver should be the sum of the held tokens and the amount received from the transfer. The fees should not be included in the max holding. ```solidity=764 require((heldTokens + amount) <= _maxWalletToken,"You are trying to buy too many tokens. You have reached the limit for one wallet.");} ``` - Max holding is checked. ```solidity=935 (uint256 tTransferAmount, uint256 tDev) = _getValues(tAmount); ``` - Receiving amount is adjusted. ```solidity=937 _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); ``` - Balance is increased by the adjusted amount.

The audit on Trustblock · Open the report
LowMissing Update `_isExcludeFee` When Updating `_owCloudtx Finance · CertiKOpen

When updating `_owner` and `Wallet_Dev` to new addresses in the following methods: - `renounceOwnership()` - `transferOwnership(address newOwner)` - `Wallet_Update_Dev(address payable wallet)` The `_isExcludeFee` identifier is not removed from the original addresses.

The audit on Trustblock · Open the report
LowMissing Zero Address ValidationCloudtx Finance · CertiKOpen

Addresses should be checked before assignment or external call to make sure they are not zero addresses. ```solidity=585 Wallet_Dev = wallet; ``` - `wallet` is not zero-checked before being used. --- ```solidity=909 uniswapV2Pair = newPair; ``` - `newPair` is not zero-checked before being used.

The audit on Trustblock · Open the report
LowPotential Sandwich AttacksCloudtx Finance · CertiKOpen

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()`

The audit on Trustblock · Open the report
LowState Variable Should Be Declared ConstantCloudtx Finance · CertiKOpen

State variables that never change should be declared as `constant` to save gas. ```solidity=386 address payable private Wallet_Burn = payable(0x000000000000000000000000000000000000dEaD); ``` - `Wallet_Burn` should be declared `constant`. --- ```solidity=387 address payable private Wallet_zero = payable(0x0000000000000000000000000000000000000000); ``` - `Wallet_zero` should be declared `constant`. --- ```solidity=395 string private _name = "CloudTx"; ``` - `_name` should be declared `constant`. --- ```solidity=396 string private _symbol = "Cloud"; ``` - `_symbol` should be declared `constant`. --- ```solidity=397 uint8 private _decimals = 9; ``` - `_decimals` should be declared `constant`. --- ```solidity=398 uint256 private _tTotal = 200000000 * 10**9; ``` - `_tTotal` should be declared `constant`. --- ```solidity=399 uint256 private _tFeeTotal; ``` - `_tFeeTotal` should be declared `constant`. --- ```solidity=407 uint256 private maxPossibleFee = 80; ``` - `maxPossibleFee` should be declared `constant`.

The audit on Trustblock · Open the report
LowUnlocked Compiler VersionCloudtx Finance · CertiKOpen

The contracts cited have an unlocked compiler version. An unlocked compiler version in the source code of the contract 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 hard to identify over a span of multiple compiler versions rather than a specific one.

The audit on Trustblock · Open the report
LowUnnecessary Use of SafeMathCloudtx Finance · CertiKOpen

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

The audit on Trustblock · Open the report
LowUnused State VariableCloudtx Finance · CertiKOpen

One or more state variables are never used in the codebase. Variable `Wallet_zero` in `CloudTx` is never used in `CloudTx`. ```solidity=387 address payable private Wallet_zero = payable(0x0000000000000000000000000000000000000000); ``` ```solidity=364 contract CloudTx is Context, IERC20, Ownable { ``` --- Variable `_tFeeTotal` in `CloudTx` is never used in `CloudTx`. ```solidity=399 uint256 private _tFeeTotal; ``` ```solidity=364 contract CloudTx is Context, IERC20, Ownable { ``` --- Variable `_previousMaxWalletToken` in `CloudTx` is never used in `CloudTx`. ```solidity=427 uint256 private _previousMaxWalletToken = _maxWalletToken; ``` ```solidity=364 contract CloudTx is Context, IERC20, Ownable { ``` --- Variable `_previousMaxTxAmount` in `CloudTx` is never used in `CloudTx`. ```solidity=431 uint256 private _previousMaxTxAmount = _maxTxAmount; ``` ```solidity=364 contract CloudTx is Context, IERC20, Ownable { ```

The audit on Trustblock · Open the report
LowUsage of `transfer`/`send` for sending EtherCloudtx Finance · CertiKOpen

It is not recommended to use Solidity's `transfer()` and `send()` functions for transferring Ether, since some contracts may not be able to receive the funds. Those functions forward only a fixed amount of gas (2300 specifically) and the receiving contracts may run out of gas before finishing the transfer. Also, EVM instructions' gas costs may increase in the future. Thus, some contracts that can receive now may stop working in the future due to the gas limitation. ```solidity=837 wallet.transfer(amount); ``` - `CloudTx.sendToWallet` uses `transfer()`.

The audit on Trustblock · Open the report

The CloudTx security record · Every CloudTx address · This address on the explorer