0xede744facd6c046ae3177238cb5afcda8a5b2920
As of 21 Nov 2026, Trustblock’s record holds 0xede744facd6c046ae3177238cb5afcda8a5b2920 on BNB Chain as a contract of DBTC. 1 audit report on Trustblock lists this address: CertiK, 26 Sep 2024. 13 findings in it are recorded as open or acknowledged.
Each report’s scope as stored on Trustblock names this address on BNB Chain.
2 High, 3 Medium, 8 Low. In the firm’s own words; statuses are the firm’s, from each report.
#### _owner In the contract `DBTCoinNew`, the privileged role `_owner` has authority over several functions. - launch() - setFeeWhiteList() - setSwapRouter() - setCurrency() - setSwapPairList() - setAntiSYNC() - setInSwap() - setTokenDistributor() - setBuyFundFee() - setBuyLPFee() - setBuyBurnFee() - setBuyMarketingFee() - setSellFundFee() - setSellLPFee() - setSellBurnFee() - setSellMarketingFee() - setSellReflowFee() - setReflowAmount() - setAddLiquidityFee() - setRemoveLiquidityFee() - setCurrencyIsEth() - setStartTradeBlock() - setMainPair() - setLastLpBurnTime() - setLpBurnRate() - setLpBurnFrequency() - setTradeFee() - setEnableOffTrade() - setTotalFundAmountReceive() - setFundAddress() - setBurnLiquidityAddress() - setDailyDropPercentage() - setOpeningPrice() - setLastUpdateTimestamp() - setClaims() - renounceOwnership() - transferOwnership() Any compromise to the privileged account may allow the hacker to take advantage of this authority, update the configuration of the contract, and transfer assets. #### fundAddress In the contract `DBTCoinNew`, the privileged role `fundAddress` has authority over several functions. - setClaims() Any compromise to the privileged account may allow the hacker to take advantage of this authority and transfer assets. --- In the updated version [0x9643C079291f36bAf1d4B2C9FB4657D4307A198a](https://bscscan.com/address/0x9643C079291f36bAf1d4B2C9FB4657D4307A198a#code), the privileged functions are changed as below. #### _owner - `Claims` - `setFeeWhiteList` - `setSwapPairList` - `setBuyFees` - `setSellFees` - `launch` - `setLastLpBurnTime` - `setLpBurnRate` - `setLpBurnFrequency` - `setTradeFee` - `setEnableOffTrade` - `setFundAddress` - `setBurnLiquidityAddress` - `setDailyDropPercentage` - `setOpeningPrice` - `setLastUpdateTimestamp` - `burnLiquidityPairTokens` #### burnLiquidityAddress - `burnLiquidityPairTokens` --- It is important to note that the functions `setDailyDropPercentage()`, `setOpeningPrice()`, and `setLastUpdateTimestamp()` allow the `_owner` role to set critical state variables: `dailyDropPercentage`, `openingPrice`, and `lastUpdateTimestamp`. These variables directly influence the calculation of the burn amount for each token transfer.
The audit on Trustblock · Open the reportAll of the `DBTC` tokens are sent to the hardcoded addresses, which are EOAs. This is a centralization risk because the accounts 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 `autoBurnLiquidityPairTokens` function in the `DBTCoinNew` contract introduces a deflationary token burn mechanism. However, this feature creates arbitrage opportunities that can be exploited by attackers for profit. For example: 1. An attacker monitors the burn mechanism and identifies when a burn operation is about to occur. 2. The attacker front-runs this burn operation and purchases DBTC tokens at a lower price. 3. Once the burn operation is executed, the token supply decreases, leading to a price increase. 4. The attacker then sells the DBTC tokens at a higher price to secure a profit.
The audit on Trustblock · Open the reportThe `_tokenTransfer` function updates the `openingPrice` during sell transactions and calculates fees based on the daily drop percentage. However, the `getPrice()` function, which determines the `currentPrice`, is dependent on the pair's reserves, making it susceptible to manipulation by whale users or malicious actors. For example: 1. A whale may sell a large amount at the start of the period (24 hours), causing the `openingPrice` to be set based on the price before this sale. 2. As subsequent sellers observe the token price dropping, they begin to sell as well. The significant difference between the `openingPrice` and `currentPrice` results in a high `dailyDropPercentage`, leading to increased fees calculated by the `calculateFee` function. As a result, users who follow the actions of the whale may suffer financial losses due to the high fees.
The audit on Trustblock · Open the reportThe current implementation incorrectly calculates the `currencyAmount` during a token swap. The variable `before` captures the balance of this contract, while `_after` captures the balance of the `_tokenDistributor`. Given that the receiver of the swap is `_tokenDistributor`, the calculation of `currencyAmount` is inappropriate and incorrect. This can lead to incorrect distribution of the currency. ```solidity ... uint256 before = IERC20(currency).balanceOf(address(this)); try _swapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens( amount, _calculateSwapToCurrencyAmount(amount), path, address(_tokenDistributor), block.timestamp ) { uint256 _after = IERC20(currency).balanceOf(address(_tokenDistributor)); uint256 currencyAmount = _after - before; ... ```
The audit on Trustblock · Open the reportThe `DBTCoinNew` contract grants the owner extensive privileges to modify critical state variables. This includes variables such as `startTradeBlock`, `currency`, `_mainPair`, and `totalFundAmountReceive`, among others. The owner’s ability to modify these critical parameters poses a significant risk, as it can lead to potential misuse or accidental misconfiguration, which could affect the contract's overall functionality and security.
The audit on Trustblock · Open the reportIn the constructor of the `DBTCoinNew` contract, several addresses are hardcoded to perform critical functions such as marketing, currency transactions, swap routing, and liquidity burning. Below is the relevant code snippet: ```solidity constructor() ERC20('DBTCoin', 'DBTC') Ownable(msg.sender) { fundAddress = payable(0x86845f569AF459ca95c032b9257E3B33a0582efC); currency = 0x55d398326f99059fF775485246999027B3197955; _swapRouter = ISwapRouter(0x10ED43C718714eb63d5aA57B78B54704E256024E); address ReceiveAddress = 0x86845f569AF459ca95c032b9257E3B33a0582efC; burnLiquidityAddress = 0x127d17465b6f6f91e71cd7bFEd11b699832DcDfa; ... } ``` Hardcoding these addresses can lead to potential issues if they are incorrect or need to be updated. This could affect the contract's functionality and security.
The audit on Trustblock · Open the reportThe `allToFunder` variable is intended to accumulate fees that are later swapped for currency and distributed to `fundAddress` and `MarketingAddress`. However, the `sellFee` used to update `allToFunder` includes `_sellFundFee`, `_sellMarketingFee`, and `_sellReflowFee`. The `_sellReflowFee` is already accounted for separately in `_reflowAmount`, leading to potential double-counting. ```solidity if (isSell) { uint256 _toSellLPFee = tAmount * _sellLPFee / 10000; _basicTransfer(sender, LPDividendsAddress, _toSellLPFee); (sellFee, burnFee, sellReflowFee, amount) = allSellFeeToAmount(tAmount, sellBurnFee); _reflowAmount += sellReflowFee; amount = amount - _toSellLPFee; allToFunder += sellFee; } else { // Other logic } ``` This miscalculation can result in `allToFunder` being greater than the actual assets available for funding purposes, potentially leading to insufficient funds for `fundAddress` and `MarketingAddress`.
The audit on Trustblock · Open the reportThe `_calculateSwapToCurrencyAmount` function in the `DBTCoinNew` contract is intended to calculate the minimum swap amount considering a slippage tolerance. However, since the calculation and the actual swap occur in the same transaction, the price could change due to sandwich attacks, rendering the function ineffective. ```solidity function _calculateSwapToCurrencyAmount(uint256 amount) public view returns (uint256) { uint256 price = getPrice(); uint256 Slippage = 2; price = amount * price / 10 ** decimals(); return price - price * Slippage / 100; } ``` In a sandwich attack, the price is manipulated before this price calculation and the swap execution, leading to potential losses or failed transactions.
The audit on Trustblock · Open the reportIt is important to emit events for sensitive actions, particularly those that can be executed by centralized roles or administrators. This ensures transparency and enables tracking of critical changes, which is essential for security and trust in the system. The absence of event logs can lead to a lack of visibility and potential information loss.
The audit on Trustblock · Open the reportThe fee variables in the contract have no set limits, allowing fees to potentially reach 100%. If this occurs, users would receive no tokens from the contract, resulting in a complete loss of their investment.
The audit on Trustblock · Open the reportA sandwich attack can occur when an attacker notices a transaction involving token swaps or liquidity additions that lacks slippage restrictions or minimum output amount settings. The attacker can exploit this by frontrunning the transaction to purchase one of the assets, thereby manipulating the exchange rate, and then backrunning the transaction to sell the asset for a profit. The referenced functions are invoked without setting slippage restrictions or minimum output amounts, making transactions that trigger these functions particularly vulnerable to sandwich attacks, especially when large input amounts are involved.
The audit on Trustblock · Open the reportIn the `DBTCoinNew` contract, the variable `buy_burnFee` is declared but never used within the contract. This results in unnecessary storage usage and potential confusion for developers and auditors reviewing the code. ```solidity uint256 public buy_burnFee; ``` The `buy_burnFee` variable is intended to represent the buy burn fee but is not used during the buy.
The audit on Trustblock · Open the reportThe DBTC security record · Every DBTC address · This address on the explorer