DBTC contract 0xede7…2920 on BNB Chain

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.

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
DBTCCertiKNot recorded (see the report)Open

Open and acknowledged findings in these reports13

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

HighCentralization Related RisksDBTC · CertiKAcknowledged

#### _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 report
HighInitial Token DistributionDBTC · CertiKAcknowledged

All 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 report
MediumArbitrage Opportunity in `autoBurnLiquidityPairToDBTC · CertiKAcknowledged

The `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 report
MediumExcessive Fees Due to Large Sell TransactionsDBTC · CertiKAcknowledged

The `_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 report
MediumIncorrect Calculation of currencyAmount in TokenDBTC · CertiKAcknowledged

The 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 report
LowExcessive Owner Privileges in `DBTCoinNew` ContraDBTC · CertiKOpen

The `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 report
LowHardcode Addresses And ValuesDBTC · CertiKOpen

In 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 report
LowIncorrect Fee Calculation Leading to Potential OvDBTC · CertiKOpen

The `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 report
LowIneffective Minimum Swap Amount Calculation Due tDBTC · CertiKOpen

The `_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 report
LowMissing Emit EventsDBTC · CertiKOpen

It 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 report
LowNo Cap on FeesDBTC · CertiKOpen

The 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 report
LowPotential Sandwich AttacksDBTC · CertiKOpen

A 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 report
LowUnused Variable `buy_burnFee`DBTC · CertiKOpen

In 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 report

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