T23 contract 0x897f…e653 on BNB Chain

0x897f2be515373cf1f899d864b5be2bd5efd4e653

As of 21 Nov 2026, Trustblock’s record holds 0x897f2be515373cf1f899d864b5be2bd5efd4e653 on BNB Chain as a contract of T23. 1 audit report on Trustblock lists this address: CertiK, 30 Dec 2022. 6 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
T23CertiKNot recorded (see the report)Open

Open and acknowledged findings in these reports6

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

HighInitial Token DistributionT23 · CertiKAcknowledged

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

The audit on Trustblock · Open the report
LowFunction state mutability can be restricted to `vT23 · CertiKOpen

The aforementioned Function `balanceOf(address owner)` can be restricted to `view`.

The audit on Trustblock · Open the report
LowMissing Proper `Transfer` Event Emit For MintingT23 · CertiKOpen

The [EIP20 (Ethereum Improvement Proposals)](https://eips.ethereum.org/EIPS/eip-20) is a standard interface that allows any tokens on Ethereum to be re-used by other applications. According to the standard, "Transfers _value amount of tokens to address _to, and MUST fire the Transfer event." However, when minting the initial T23 tokens during the deployment, the project does not emit a `Transfer` event as specified in the EIP20. ```solidity=14 constructor() { balances[msg.sender] = totalSupply; } ```

The audit on Trustblock · Open the report
LowPotential Risk On `approve()`/`transferFrom()` MeT23 · CertiKOpen

The `Token` implementation is vulnerable to [a known ERC20 race condition issue](https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729), which could lead to token theft. When a user calls `approve()` for a second time on a spender that has already been allowed, the spender could call `transferFrom()` to transfer the previous value and still receive the authorization to transfer the new value. Exploit scenario: 1. Alice calls `approve(Bob, 100)` to allow Bob to spend 100 tokens. 2. Alice changes her mind and calls `approve(Bob, 50)`. 3. Bob observes the second `approve(Bob, 50)` function call and calls `transferFrom(Alice, Bob, 100)` before the second `approve(Bob, 50)` call. 4. The above scenario can be achieved by front-running. In this case, Bob can transfer another 50 tokens from Alice and in total, he transferred 150 tokens from Alice.

The audit on Trustblock · Open the report
LowState Variable Can Be Declared ConstantT23 · CertiKOpen

State variables that never change should be declared as `constant` to save gas. ```solidity=6 uint public totalSupply = 1000000000000000 * 10 ** 18; ``` - `totalSupply` should be declared `constant`. --- ```solidity=7 string public name = "2023"; ``` - `name` should be declared `constant`. --- ```solidity=8 string public symbol = "T23"; ``` - `symbol` should be declared `constant`. --- ```solidity=9 uint public decimals = 18; ``` - `decimals` should be declared `constant`.

The audit on Trustblock · Open the report
LowUnlocked Compiler VersionT23 · 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

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