0x1010e325e2171269b1320f6d02bb1758b861fb52
As of 21 Nov 2026, Trustblock’s record holds 0x1010e325e2171269b1320f6d02bb1758b861fb52 on BNB Chain as a contract of AiEternal. 1 audit report on Trustblock lists this address: CertiK, 27 Jul 2023. 8 findings in it are recorded as open or acknowledged.
Each report’s scope as stored on Trustblock names this address on BNB Chain.
| Audit | Security firm | Date | Commit named in the report | Report |
|---|---|---|---|---|
| AIEternal - Audit | CertiK | Not recorded (see the report) | Open |
2 High, 6 Low. In the firm’s own words; statuses are the firm’s, from each report.
In the contract `Ownable`, the role `_owner` has authority over the functions: - `renounceOwnership()` to leave the contract without the owner. - `transferOwnership()` to transfer the ownership of the contract to a new account. Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and affect activities related to the owner role.
The audit on Trustblock · Open the reportAll of the **totalSupply_** tokens are sent to the contract owner. 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 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 reportIf `msg.value > serviceFee_`, the excess Ether held in this contract will not be returned to the user's account. Consequently, the caller will end up paying more than what is actually required.
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=477 payable(serviceFeeReceiver_).transfer(serviceFee_); ``` - `serviceFeeReceiver_` is not zero-checked before being used.
The audit on Trustblock · Open the reportThe methods `increaseApproval` and `decreaseApproval` are unsafe. Here is the scenario: 1. Bob is allowed to transfer zero Alice's tokens. 2. Alice allows Bob to transfer 100 of here tokens via approve or `increaseApproval` method and transaction is executed successfully. 3. Alice sees that Bob is now allowed to transfer 100 of her tokens. 4. After some time, Alice uses `decreaseApproval` method to decrease by 100 the number of her tokens Bob is allowed to transfer, and transaction is executed successfully and proper Approval event was logged. 5. Alice sees that Bob is allowed to transfer 0 of her tokens. 6. Now Alice may think that once `decreaseApproval` transaction was executed successfully, then Bob didn't manage to transfer any of her tokens before the allowance was decreased, but this assumption is wrong. 7. Actually, Bob may or may not have transferred Alice's tokens before allowance was decreased, and Alice has no easy way to know for sure whether Bob transferred her tokens or not.
The audit on Trustblock · Open the reportThe `approve()` and `transferFrom()` functions could be used in an attack that allows a spender to transfer more tokens than the owner of the tokens ever wanted to allow the spender to transfer. Here is a possible attack scenario: - Alice allows Bob to transfer N of Alice's tokens (N>0) by calling approve method on Token smart contract passing Bob's address and N as method arguments. - After some time, Alice decides to change from N to M (M>0) the number of Alice's tokens Bob is allowed to transfer, so she calls approve method again, this time passing Bob's address and M as method arguments. - Bob notices Alice's second transaction before it was mined and quickly sends another transaction that calls the `transferFrom()` function to transfer N Alice's tokens somewhere. - If Bob's transaction is executed before Alice's transaction, then Bob will successfully transfer N Alice's tokens and will gain the ability to transfer another M tokens. - Before Alice noticed that something went wrong, Bob calls `transferFrom()` again, this time to transfer M Alice's tokens - So, Alice's attempt to change Bob's allowance from N to M (N>0 and M>0) made it possible for Bob to transfer N+M of Alice's tokens, while Alice never wanted to allow so many of her tokens to be transferred by Bob. ERC20 API: [An Attack Vector on Approve/TransferFrom Methods](https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/edit#heading=h.m9fhqynw2xvt)
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=201 library SafeMath { ``` - An implementation of `SafeMath` library is found. --- ```solidity=450 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `StandardToken` contract. ```solidity=599 _approve( sender, _msgSender(), _allowances[sender][_msgSender()].sub( amount, "ERC20: transfer amount exceeds allowance" ) ); ``` - `SafeMath.sub` is called in `transferFrom` function of `StandardToken` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 10) are shown above.*
The audit on Trustblock · Open the reportIt is not recommended to use Solidity's `transfer()` and `send()` functions for transferring native tokens, 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=477 payable(serviceFeeReceiver_).transfer(serviceFee_); ``` - `StandardToken.constructor` uses `transfer()`.
The audit on Trustblock · Open the reportThe AiEternal security record · Every AiEternal address · This address on the explorer