1MDC Coin contract 0xf43c…c673 on BNB Chain

0xf43c9b40c9361b301019c98fb535affb3ec6c673

As of 21 Nov 2026, Trustblock’s record holds 0xf43c9b40c9361b301019c98fb535affb3ec6c673 on BNB Chain as a contract of 1MDC Coin. 1 audit report on Trustblock lists this address: CertiK, 20 Jun 2024. 18 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
1MDC token - auditCertiKNot recorded (see the report)Open

Open and acknowledged findings in these reports18

3 High, 3 Medium, 12 Low. In the firm’s own words; statuses are the firm’s, from each report.

HighCentralization Risks in Token.sol1MDC token - audit · CertiKAcknowledged

In the contract `Ownable` the role `_owner` has authority over the functions shown in the diagram below. Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and transfer ownership and renounce ownership. ![](https://accelerator-tasks-prod.acc.corp.certik.com/11ef-2ac3-a134dc00-8af4-7b056a4e2834/diagrams/centralization_Token-Ownable-_owner.svg) In the contract `Token` the role `_owner` has authority over the functions shown in the diagram below. Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and add addresses to exclude fees, add addresses to exclude fees VIP, set start time and add pairs. ![](https://accelerator-tasks-prod.acc.corp.certik.com/11ef-2ac3-a134dc00-8af4-7b056a4e2834/diagrams/centralization_Token-Token-_owner.svg) In the contract `Token` the role `_tokenOwner` has authority over the functions shown in the diagram below. Any compromise to the `_tokenOwner` account may allow the hacker to take advantage of this authority and rescue token and cancel inviters. ![](https://accelerator-tasks-prod.acc.corp.certik.com/11ef-2ac3-a134dc00-8af4-7b056a4e2834/diagrams/centralization_Token-Token-_tokenOwner.svg)

The audit on Trustblock · Open the report
HighCentralized Balance Manipulation in `rescueToken(1MDC token - audit · CertiKAcknowledged

In the contract Token, the role `_tokenOwner` has the authority to withdraw all native coins and any amount of any tokens without sanity restriction. Any compromise to the `_tokenOwner` account may allow a hacker to take advantage of this authority and drain all assets from the contract. ```sol=1184 function rescueToken(address tokenAddress, uint256 tokens) public returns (bool success) { require(_tokenOwner == msg.sender); if(address(this).balance > 0){ payable(_tokenOwner).transfer(address(this).balance); } return IERC20(tokenAddress).transfer(msg.sender, tokens); } ```

The audit on Trustblock · Open the report
HighInitial Token Distribution1MDC token - audit · CertiKAcknowledged

All of the `1MDC` tokens are sent to the `tokenOwner` address. The `tokenOwner` address is a passed-in parameter through the `constructor()` function, and it could be an externally-owned account (EOA) address. 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.

The audit on Trustblock · Open the report
MediumInaccurate `totalTokenAmount` Calculation1MDC token - audit · CertiKAcknowledged

The current smart contract computes total token circulating amount by subtracting the balances of specific excluded addresses from the `totalSupply`. The formula used is `totalTokenAmount = totalSupply - balanceOf(excluded address)`. Here the `uniswapV2Pair` address is the only excluded address. This approach is volatile and can lead to inaccuracies and manipulation of the total token circulating supply figure. If large balances of excluded addresses are deducted, it may not accurately reflect the supply available to the general public. Moreover, these addresses can alter the circulating supply by transferring tokens in or out, potentially affecting any functionality that relies on the circulating supply calculation. ```sol=1294 uint256 totalTokenAmount = super.totalSupply() - super.balanceOf(uniswapV2Pair); ```

The audit on Trustblock · Open the report
MediumPotential Sandwich Attacks1MDC token - audit · CertiKAcknowledged

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 backrunning (after the transaction being attacked) a transaction to sell the asset. An attacker can use a flashloan as the initial funds for an exploit to enlarge the profit or manipulate the token price in decentralized exchanges. If swapping/adding liquidity happens without price and slippage control and can be triggered on-chain by anyone, then an attacker can exploit the contract. The below functions call UniswapV2 interfaces without setting restrictions on slippage or minimum output amount, so transactions triggering the function are vulnerable to sandwich attacks, especially when the input amount is large. ```1237 function swapTokensForEth(uint256 tokenAmount) private { // generate the uniswap pair path of token -> weth address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, 0, // accept any amount of ETH path, address(this), block.timestamp ); } ``` Function `Token.swapTokensForEth` invokes `uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens` without setting restrictions on slippage or minimum output amount, which may be triggered by anyone. --- ```1251 function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private { uniswapV2Router.addLiquidityETH{value: ethAmount}( address(this), tokenAmount, 0, 0, _destroyAddress, block.timestamp ); } ``` Function `Token.addLiquidity` invokes `uniswapV2Router.addLiquidityETH` without setting restrictions on slippage or minimum output amount, which may be triggered by anyone. --- ```1262 function swapPoolTokensForUsdt(uint256 tokenAmount) private { address[] memory path = new address[](3); path[0] = address(this); path[1] = _baseToken; path[2] = address(USDT); uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens( tokenAmount, 0, path, address(this), block.timestamp ); } ``` Function `Token.swapPoolTokensForUsdt` invokes `uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens` without setting restrictions on slippage or minimum output amount, which may be triggered by anyone.

The audit on Trustblock · Open the report
MediumTransfer After Pool Token Destroyed1MDC token - audit · CertiKAcknowledged

In the `_transfer()` function of the contract `Token`, if the `to` address is pair, after the start time check and the distribution of the USDT reward, it will call the `destroyPoolToken()` function. Here the `destroyPoolToken()` function calls `super._transfer(uniswapV2Pair, _destroyAddress, ...)` to burn a certain amount of tokens from the Uniswap pool to the pre-defined `_destroyAddress`. Then the function calls `IUniswapV2Pair(uniswapV2Pair).sync()` to update the Uniswap pool's reserves, since the asset balance changes does not go through the usual `swap()`, `addLiquidity()`, or `removeLiquidity()` UniswapV2 functions ```sol=1079 function destroyPoolToken() private { uint256 nowHour = block.timestamp.div(daySecond); if(nowHour > lastHour){ lastHour = nowHour; uint256 haveAmount = super.balanceOf(uniswapV2Pair); if(haveAmount > 10**22){ super._transfer(uniswapV2Pair, _destroyAddress, haveAmount.div(100).mul(12).div(24)); IUniswapV2Pair(uniswapV2Pair).sync(); } } } ``` Now if we look back to the `_transfer()` function, after the `else if` statement finished, the function will call the `super._transfer()` method to increase the 1MDC token amount by direct token transferring without calling the `sync()` function. ```sol=1131 }else if(_isPairs[to]){ require(startTime < block.timestamp,"startTime"); _splitUsdt2BuyTokenHolder(); destroyPoolToken(); super._transfer(from, address(this), amount.div(100).mul(3)); amount = amount.div(100).mul(97); //_transfer2otherAddress(amount.div(10000)); }else{ } } super._transfer(from, to, amount); ```

The audit on Trustblock · Open the report
LowDiscussion on the Usage of `tx.origin`1MDC token - audit · CertiKOpen

EIP3074 introduces two EVM instructions AUTH and AUTHCALL. The AUTH instruction sets a context variable, 'authorized', based on an ECDSA signature, while AUTHCALL enables sending a call as authorized. This pivotal enhancement allows smart contracts to delegate control of an EOA, enabling transactions to be sent within the context of said EOA, effectively bypassing certain checks. Moreover, the usage of `tx.origin` is heavily discouraged due to potential phishing attempts. For contracts, `tx.origin` lacks transparency. In a call chain scenario such as A->B->C->D, within contract D, `msg.sender` will be C, while `tx.origin` will trace back to A. If the origin is crucial within D, a method of propagation is suggested: each contract (B, C, D) could take an extra parameter to carry the origin. This way, A would pass its address (this) to B, B to C, and C to D. However, relying solely on `tx.origin` for authorization is susceptible to abuse by malicious contracts, especially if a legitimate user interacts with the malicious one. Consequently, it is not recommended to employ tx.origin for authorization in Solidity, as emphasized in the Solidity documentation. Refer to: [Solidity Documentation - Security Considerations](https://docs.soliditylang.org/en/v0.8.18/security-considerations.html#tx-origin)

The audit on Trustblock · Open the report
LowMissing Zero Address Validation1MDC token - audit · CertiKOpen

Addresses 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=232 _owner = msgSender; ``` - `msgSender` is not zero-checked before being used. --- ```solidity=1016 _tokenOwner = tokenOwner; ``` - `tokenOwner` is not zero-checked before being used.

The audit on Trustblock · Open the report
LowNon-refundable Purchase if less than minimum thre1MDC token - audit · CertiKOpen

In the contract `Token`, the `receive()` function handles the purchase of the `1MDC` token. If the `startTime` is reached, and if the `msg.value` is greater than or equal to `10**10`, then the contract will transfer the `1MDC` token to the `msg.sender` and also send the native coin to to the inviters. Finally the function will send the leftover native coins to the `_bnbReciverAddress`. However, if the minimum amount of purchase is not satisfied, i.e. the `msg.value` is less than `10**10`, the transaction will not be reverted. The full amount of the `msg.value` will be redirected to the `_bnbReciverAddress`. ```sol=1032 receive() external payable { if(startTime > block.timestamp){ if(msg.value >= 10**10){ uint256 sendAmount = getUserMintAmount(msg.value); if(sendAmount > 0){ super._transfer(_tokenOwner, msg.sender, sendAmount); _takeInviterFee(msg.sender, msg.value); } } _bnbReciverAddress.transfer(address(this).balance); } } ``` In addition, in the `getUserMintAmount()`, we noticed that the price of `1MDC : BNB` is hardcoded as `1 BNB = 1 * 10 ** 28 / 10 ** 18 1MDC => 1 BNB = 10**10 1MDC`, we would like to learn if there are any other mechanisms to maintain the price.

The audit on Trustblock · Open the report
LowRedundant conditions in `if` statement of the `_t1MDC token - audit · CertiKOpen

In the `_transfer()` function of the `Token` contract, there is an `if` statement to control whether to call the `swapAndLiquify()` function. There are two redundant statements in the `if` statement: `!swapping` and `swapAndLiquifyEnabled`. Both the `swapping` and `swapAndLiquifyEnabled` variables are state variables, where `swapping` is never set and by default initialized to `false` by Solidity, and `swapAndLiquifyEnabled` is initialized to `true`. These two variables are not set or used in other functions and the current value of `!swapping && swapAndLiquifyEnabled` is always true. ```sol=1108 if ( balanceOf(address(this)) > super.balanceOf(uniswapV2Pair).div(500) ) { if ( !swapping && _tokenOwner != from && _tokenOwner != to && to == uniswapV2Pair && swapAndLiquifyEnabled ) { swapAndLiquify(); } ```

The audit on Trustblock · Open the report
LowState Variable Should Be Declared Constant1MDC token - audit · CertiKOpen

State variables that never change should be declared as `constant` to save gas. ```solidity=987 bool private swapping; ``` - `swapping` should be declared `constant`. --- ```solidity=989 address _cakeRouter = address(0x10ED43C718714eb63d5aA57B78B54704E256024E);//router ``` - `_cakeRouter` should be declared `constant`. --- ```solidity=990 address _baseToken = address(0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c);//wbnb ``` - `_baseToken` should be declared `constant`. --- ```solidity=991 IERC20 public USDT = IERC20(0x55d398326f99059fF775485246999027B3197955); ``` - `USDT` should be declared `constant`. --- ```solidity=993 address _destroyAddress = address(0x000000000000000000000000000000000000dEaD); ``` - `_destroyAddress` should be declared `constant`. --- ```solidity=994 address payable _bnbReciverAddress = payable(address(0xB408CD6D80dC8cabb0f0cEF0226A4FdE11704Fad)); ``` - `_bnbReciverAddress` should be declared `constant`. --- ```solidity=995 address defaultAddress = address(0xB408CD6D80dC8cabb0f0cEF0226A4FdE11704Fad); ``` - `defaultAddress` should be declared `constant`. --- ```solidity=1000 bool public swapAndLiquifyEnabled = true; ``` - `swapAndLiquifyEnabled` should be declared `constant`. --- ```solidity=1003 uint256 daySecond = 3600; ``` - `daySecond` should be declared `constant`. --- ```solidity=1029 uint256 public baseBnbAmount = 10**18; ``` - `baseBnbAmount` should be declared `constant`. --- ```solidity=1030 uint256 public oneBaseAmount = 10**28; ``` - `oneBaseAmount` should be declared `constant`.

The audit on Trustblock · Open the report
LowThird-Party Dependency Usage1MDC token - audit · CertiKOpen

The contract is serving as the underlying entity to interact with one or more third party protocols. The scope of the audit treats third party entities as black boxes and assumes their functional correctness. However, in the real world, third parties can be compromised and this may lead to lost or stolen assets. In addition, upgrades of third parties can possibly create severe impacts, such as increasing fees of third parties, migrating to new LP pools, etc. --- ```solidity=988 address public uniswapV2Pair; address _cakeRouter = address(0x10ED43C718714eb63d5aA57B78B54704E256024E); //router address _baseToken = address(0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c); //wbnb IERC20 public USDT = IERC20(0x55d398326f99059fF775485246999027B3197955); ``` - The contract `Token` interacts with third party contract with `IUniswapV2Pair` interface via `uniswapV2Pair`. - The contract `Token` interacts with third party contract with `IERC20` interface via `USDT` and `_baseToken`. --- ```solidity=1010 IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(_cakeRouter); address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()) ``` - The contract `Token` interacts with third party contract with `IUniswapV2Router02` interface via `uniswapV2Router`.

The audit on Trustblock · Open the report
LowUnchecked ERC-20 `transfer()`/`transferFrom()` Ca1MDC token - audit · CertiKOpen

The return values of the `transfer()` and `transferFrom()` calls in the smart contract are not checked. Some ERC-20 tokens' transfer functions return no values, while others return a bool value, they should be handled with care. If a function returns `false` instead of reverting upon failure, an unchecked failed transfer could be mistakenly considered successful in the contract. ```solidity=1305 USDT.transfer(user,buyRewardTokenAmount); ``` --- ```solidity=1315 USDT.transfer(user,buyRewardTokenAmount); ```

The audit on Trustblock · Open the report
LowUnnecessary Use of SafeMath1MDC token - audit · 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. ```solidity=275 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `ERC20` contract. ```solidity=419 _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 13) are shown above.* --- ```solidity=620 library SafeMath { ``` - An implementation of `SafeMath` library is found. --- ```solidity=275 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `ERC20` contract. ```solidity=1046 return bnbAmount.mul(oneBaseAmount).div(baseBnbAmount); ``` - `SafeMath.mul` is called in `getUserMintAmount` function of `Token` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 34) are shown above.*

The audit on Trustblock · Open the report
LowUnused Return Value1MDC token - audit · CertiKOpen

The 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=1198 (uint r0,,) = IUniswapV2Pair(address(uniswapV2Pair)).getReserves(); ``` --- ```solidity=1211 (uint reserves0,,) = IUniswapV2Pair(address(uniswapV2Pair)).getReserves(); ``` --- ```solidity=1252 uniswapV2Router.addLiquidityETH{value: ethAmount}( address(this), tokenAmount, 0, 0, _destroyAddress, block.timestamp ); ```

The audit on Trustblock · Open the report
LowUse case of State variable `ktNum`1MDC token - audit · CertiKOpen

In the `Token` contract, there is a state variable `ktNum`. It is initialized to be `173` and used in the function `_transfer2otherAddress()`. Our current understanding is that this value is to generate `_receiveD` addresses to transfer small amounts of tokens. ```sol=1223 uint160 ktNum = 173; uint160 constant MAXADD = ~uint160(0); function _transfer2otherAddress( uint256 amount ) private { address _receiveD; for (uint256 i = 0; i < 3; i++) { _receiveD = address(MAXADD/ktNum); ktNum = ktNum+1; super._transfer(address(this), _receiveD, amount.div(i+10)); } } ```

The audit on Trustblock · Open the report
LowUse Cases of Unused Functions1MDC token - audit · CertiKOpen

In the `Token` contract, there are functions that are implemented but never used: * `_isAddLiquidityV2()` * `_isDelLiquidityV2()` * `_transfer2otherAddress()` These functions have visibilities of either `internal` or `private`, which means if the functions are not used in the contract, the functions are not callable by external users or contracts either.

The audit on Trustblock · Open the report
LowVariable That Could Be Declared As Immutable1MDC token - audit · CertiKOpen

The linked variables assigned in the constructor can be declared as `immutable`. Immutable state variables can be assigned during contract creation but will remain constant throughout the lifetime of a deployed contract. A big advantage of immutable variables is that reading them is significantly cheaper than reading from regular state variables since they will not be stored in storage. ```sol=984 IUniswapV2Router02 public uniswapV2Router; ``` ```sol=988 address public uniswapV2Pair; ```

The audit on Trustblock · Open the report

The 1MDC Coin security record · Every 1MDC Coin address · This address on the explorer