0x8cedb0680531d26e62abdbd0f4c5428b7fdc26d5
As of 21 Nov 2026, Trustblock’s record holds 0x8cedb0680531d26e62abdbd0f4c5428b7fdc26d5 on Ethereum as a contract of Micro GPT. 1 audit report on Trustblock lists this address: CertiK, 6 Jan 2025. 12 findings in it are recorded as open or acknowledged.
Each report’s scope as stored on Trustblock names this address on Ethereum.
| Audit | Security firm | Date | Commit named in the report | Report |
|---|---|---|---|---|
| MicroGPT - Audit | CertiK | Not recorded (see the report) | Open |
1 High, 2 Medium, 9 Low. In the firm’s own words; statuses are the firm’s, from each report.
All of the `_tTotal` tokens are sent to the contract deployer. This is a centralization risk because the deployer 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. As of Jun 6, 2024, the addresses of major holders are listed below: - 100% of the tokens are in the owner account [**0x7a84f3EF17103CA2716E66fF1858A32c7911b5f4**](https://etherscan.io/address/0x7a84f3EF17103CA2716E66fF1858A32c7911b5f4) --- Important Note: Certain identification procedures were attempted to be applied to the project team in order to better understand the centralization situation and potential risks of the project. We strongly advise end users to conduct further research and exercise due diligence before engaging with the project given the centralization related risks. It is crucial for end users to independently verify and assess all available information.
The audit on Trustblock · Open the reportThe `MicroGPT` contract specifies the Solidity version pragma as `pragma solidity >=0.6.0 <0.9.0;`. However, versions prior to `0.8.0` do not provide built-in protection against arithmetic overflow/underflow. Consequently, the `finalizeTransfer` function poses a security risk as it lacks a check to verify that the `from` address has a sufficient balance before subtracting the `amount`: ```solidity _tOwned[from] -= amount; uint256 amountReceived = (takeFee) ? takeTaxes(from, amount, buy, sell) : amount; _tOwned[to] += amountReceived; ``` Additionally, the contract employs `block.chainid`, which was introduced in Solidity version `0.8.0`. This creates a contradiction since the use of `block.chainid` suggests a minimum compiler version of `0.8.0`, which would inherently include the aforementioned arithmetic overflow/underflow protection.
The audit on Trustblock · Open the reportA 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. ### External call(s) ```solidity=324 try initializer.getConfig() returns (address router, address constructorLP) { dexRouter = IRouter02(router); lpPair = constructorLP; lpPairs[lpPair] = true; _approve(_owner, address(dexRouter), type(uint256).max); _approve(address(this), address(dexRouter), type(uint256).max); } catch { revert(); } ``` ### State variables written after the call(s) ```solidity=325 dexRouter = IRouter02(router); lpPair = constructorLP; lpPairs[lpPair] = true; ``` ```solidity=325 dexRouter = IRouter02(router); lpPair = constructorLP; lpPairs[lpPair] = true; ``` ```solidity=325 dexRouter = IRouter02(router); lpPair = constructorLP; lpPairs[lpPair] = true; ``` *Note: Only a sample of 3 assignments (out of 5) are shown above.* --- ### External call(s) ```solidity=565 try initializer.setLaunch(lpPair, uint32(block.number), uint64(block.timestamp), _decimals) {} catch {} ``` ```solidity=566 try initializer.getInits(balanceOf(lpPair)) returns (uint256 initThreshold, uint256 initSwapAmount) { swapThreshold = initThreshold; swapAmount = initSwapAmount; } catch {} ``` ### State variables written after the call(s) ```solidity=571 launchStamp = block.timestamp; ``` ```solidity=568 swapAmount = initSwapAmount; ``` ```solidity=567 swapThreshold = initThreshold; ``` --- ### External call(s) ```solidity=597 try initializer.checkUser(from, to, amount) returns (bool check) { checked = check; } catch { revert(); } ``` ### State variables written after the call(s) ```solidity=605 _tOwned[from] -= amount; ``` ```solidity=607 _tOwned[to] += amountReceived; ``` ```solidity=610 _checkLiquidityAdd(from, to); ``` * This function call executes the following assignment(s). * In `MicroGPT._checkLiquidityAdd`, * `_hasLiqBeenAdded = true` *Note: Only a sample of 3 assignments (out of 6) are shown above.*
The audit on Trustblock · Open the reportIn the `MicroGPT` contract, the `setLpPair` function enables the `owner` to modify the `lpPairs` mapping for a given pair address. However, this function's behavior could be misconstrued due to its naming and lack of direct update on the state variable `lpPair`, unlike the `setNewRouter` function, which explicitly updates this state variable. Additionally, the `lpPairs` mapping's purpose and usage within the contract's logic are inadequately documented. Given that `lpPairs` influences transaction processing in the `_transfer` and `finalizeTransfer` functions, its precise function and the business rules it enforces are crucial for a proper audit.
The audit on Trustblock · Open the reportThe 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=484 require(balanceOf(to) + amount <= _maxWalletSize, "Transfer amount exceeds the maxWalletSize."); ``` - Max holding is checked. ```solidity=606 uint256 amountReceived = (takeFee) ? takeTaxes(from, amount, buy, sell) : amount; ``` - Receiving amount is adjusted. ```solidity=607 _tOwned[to] += amountReceived; ``` - Balance is increased by the adjusted amount.
The audit on Trustblock · Open the reportThe **require** can be used to check for conditions and throw an exception if the condition is not met. It is better to provide a string message containing details about the error that will be passed back to the caller.
The audit on Trustblock · Open the reportAny mismatched type or interface casting would cause failures in the contract execution. `this` is cast to `Initializer`, however it is declared as `MicroGPT`. ```solidity=552 initializer = Initializer(address(this)); ``` - `this` is cast from `MicroGPT` to `address`. - `address(this)` is cast from `address` to `Initializer`. --- `this` is cast to `Initializer`, however it is declared as `MicroGPT`. ```solidity=563 initializer = Initializer(address(this)); ``` - `this` is cast from `MicroGPT` to `address`. - `address(this)` is cast from `address` to `Initializer`.
The audit on Trustblock · Open the reportA sandwich attack may 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 (executing before the target) a transaction to purchase one of the assets and make profits by backrunning (executing after the target) a transaction to sell the asset. The cited 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.
The audit on Trustblock · Open the reportThe aforementioned lines perform a low level call to execute transactions but the return value is not checked in either case.
The audit on Trustblock · Open the reportIn the `MicroGPT` smart contract, the function `approveContractContingency` grants the contract owner the ability to specify a maximum allowance for the `dexRouter`. However, the `dexRouter` address can only be assigned via the `setNewRouter` function, which inherently approves the maximum allowance for the newly assigned `dexRouter`: ```solidity _approve(address(this), address(dexRouter), type(uint256).max); ``` As a result, the action of setting a maximum allowance through `approveContractContingency` is redundant since `setNewRouter` already performs this approval.
The audit on Trustblock · Open the reportAfter [EIP-1884](https://eips.ethereum.org/EIPS/eip-1884) was included in the Istanbul hard fork, it is not recommended to use `.transfer()` or `.send()` for transferring ether as these functions have a hard-coded value for gas costs making them obsolete as they are forwarding a fixed amount of gas, specifically `2300`. This can cause issues in case the linked statements are meant to be able to transfer funds to other contracts instead of EOAs.
The audit on Trustblock · Open the reportSome tokens do not implement the ERC20 standard properly but are still accepted by most code that accepts ERC20 tokens. For example Tether (USDT)'s `transfer()` and `transferFrom()` functions on L1 do not return booleans as the specification requires, and instead have no return value. When these sorts of tokens are cast to `IERC20`, their [function signatures](https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca) do not match and therefore the calls made and will revert.
The audit on Trustblock · Open the reportThe Micro GPT security record · Every Micro GPT address · This address on the explorer