0x50c7584be73d20760f1947ffcbf7942822c968c8
As of 21 Nov 2026, Trustblock’s record holds 0x50c7584be73d20760f1947ffcbf7942822c968c8 on BNB Chain as a contract of Trust AI. 1 audit report on Trustblock lists this address: CertiK, 6 Dec 2023. 15 findings in it are recorded as open or acknowledged.
Each report’s scope as stored on Trustblock names this address on BNB Chain.
1 High, 1 Medium, 13 Low. In the firm’s own words; statuses are the firm’s, from each report.
All of the `TRT` tokens, which is in amount of `20000000 * (10**_decimals);`, are sent to the contract deployer or one or several externally-owned account (EOA) addresses. This is a centralization risk because the deployer or the owner(s) of the EOAs can distribute tokens without obtaining the consensus of the community. Any compromise to these addresses may allow a hacker to steal and sell tokens on the market, resulting in severe damage to the project.
The audit on Trustblock · Open the reportThe contract `TRUSTAI` has a whitelist, `_isExcludedFromFees`, for excluding some addresses from the fee mechanism, e.g: ```solidity=978 excludeFromFees(_owner, true); excludeFromFees(address(this), true); excludeFromFees(address(0xdead), true); ``` However, the address of the **Liquidity Pool Pair**, which is `uniswapV2Pair`, is not excluded from the fees. Therefore, it might lead to an **unbalanced** liquidity pool exploit.
The audit on Trustblock · Open the reportHalf the amount of liquidity tokens are not swapped, therefore the denominator `totalTokensToSwap` does not correspond to the actual BNB balance change. The resulting `ethForMarketing`, `ethForDev`, and `ethForBuyBack` will be a little less than deserved, and `ethForLiquidity` will be more than what should be when `amountToSwapForETH` is used as the denominator.
The audit on Trustblock · Open the reportPrivileged functions that update state variables should emit relevant events as notifications.
The audit on Trustblock · Open the reportAddresses are not validated before assignment or external calls, potentially allowing the use of zero addresses and leading to unexpected behavior or vulnerabilities. For example, transferring tokens to a zero address can result in a permanent loss of those tokens. ```solidity=1063 marketingWallet = newMarketingWallet; ``` - `newMarketingWallet` is not zero-checked before being used. --- ```solidity=1068 devWallet = newWallet; ``` - `newWallet` is not zero-checked before being used. --- ```solidity=1073 buyBackWallet = newWallet; ``` - `newWallet` is not zero-checked before being used.
The audit on Trustblock · Open the reportThe function `swapTokensForEth()` doesn't check if the `tokenAmount` variable is above zero before executing. This could cause gas costs for each function call.
The audit on Trustblock · Open the reportA 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 backrunning (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: - `addLiquidityETH()` - `swapExactTokensForETHSupportingFeeOnTransferTokens()`
The audit on Trustblock · Open the reportVariables are written but never read and subsequently written again, suggesting potential inefficiencies or logic errors in the code. This may lead to confusion when analyzing the code or impact the performance of the smart contract during execution. `success` is written twice, but not used in-between. ```solidity=1234 (success,) = address(devWallet).call{value: ethForDev}(""); ``` ```solidity=1235 (success,) = address(buyBackWallet).call{value: ethForBuyBack}(""); ```
The audit on Trustblock · Open the reportThe `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. ```solidity=177 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `ERC20` contract. ```solidity=299 _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); ``` - `SafeMath.sub` is called in `transferFrom` function of `ERC20` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 11) are shown above.* --- ```solidity=454 library SafeMath { ``` - An implementation of `SafeMath` library is found. --- ```solidity=177 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `ERC20` contract. ```solidity=1128 fees = amount.mul(sellTotalFees).div(100); ``` - `SafeMath.mul` is called in `_transfer` function of `TRUSTAI` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 14) are shown above.*
The audit on Trustblock · Open the report```solidity=711 library SafeMathInt { ``` - The library `SafeMathInt` is declared but never used.
The audit on Trustblock · Open the reportSome events are never emitted, which can lead to confusion and code maintainability issues. ```solidity=900 event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress); ```
The audit on Trustblock · Open the reportThe 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=1181 try uniswapV2Router.addLiquidityETH{value: ethAmount}( address(this), tokenAmount, 0, // slippage is unavoidable 0, // slippage is unavoidable deadAddress, block.timestamp ) {} catch {} ```
The audit on Trustblock · Open the reportSome state variables are not used in the codebase. This can lead to incomplete functionality or potential vulnerabilities if these variables are expected to be utilized. Variable `MAX_INT256` in `SafeMathInt` is never used in `SafeMathInt`. ```solidity=653 int256 private constant MAX_INT256 = ~(int256(1) << 255); ``` ```solidity=651 library SafeMathInt { ```
The audit on Trustblock · Open the reportThe linked variable assigned in the constructor can be declared as `immutable`. Immutable state variable can be assigned during contract creation but will remain constant throughout the lifetime of a deployed contract. A big advantage of immutable variable is that reading them is significantly cheaper than reading from regular state variable since they will not be stored in storage.
The audit on Trustblock · Open the reportIn the function `swapBack()`, the event `SwapAndLiquify` is emitted mistakenly. The `tokensForLiquidity` is set as zero at Line 1239. It is falsely used in the event. ```solidity=1239 emit SwapAndLiquify(amountToSwapForETH, ethForLiquidity, tokensForLiquidity); ```
The audit on Trustblock · Open the reportThe Trust AI security record · Every Trust AI address · This address on the explorer