THE Protocol contract 0x0cba…2861 on Ethereum

0x0cba60ca5ef4d42f92a5070a8fedd13be93e2861

As of 21 Nov 2026, Trustblock’s record holds 0x0cba60ca5ef4d42f92a5070a8fedd13be93e2861 on Ethereum as a contract of THE Protocol. 1 audit report on Trustblock lists this address: CertiK, 31 Oct 2022. 14 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 Ethereum.

AuditSecurity firmDateCommit named in the reportReport
THE Protocol ($THE) - AuditCertiKNot recorded (see the report)Open

Open and acknowledged findings in these reports14

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

HighBurn `$THE` Tokens in the `$THE - ETH` pairTHE Protocol ($THE) - Audit · CertiKOpen

The function `autoBurnLiquidityPairTokens()` that would be triggered in during the transferring of the `THE` token and the function `manualBurnLiquidityPairTokens()` that could be invoked by the owner can burn the `THE` tokens of the `uniswapV2Pair` pair. However, it might not be appropriate that the `THE` tokens are burnt without the approval of other liquidity holders. This will cause the loss of other liquidity holders compared to those who do not hold liquidity.

The audit on Trustblock · Open the report
HighInitial Token DistributionTHE Protocol ($THE) - Audit · CertiKOpen

All of the `THE` tokens are sent to the contract deployer when deploying the contract. This could be a centralization risk as the deployer can distribute `THE` tokens without obtaining the consensus of the community.

The audit on Trustblock · Open the report
LowFunction Should Be Declared ExternalTHE Protocol ($THE) - Audit · CertiKOpen

The functions which are never called internally within the contract should have external visibility for gas optimization. ```solidity=83 function renounceOwnership() public virtual onlyOwner { ``` --- ```solidity=91 function transferOwnership(address newOwner) public virtual onlyOwner { ``` --- ```solidity=280 function name() public view virtual override returns (string memory) { ``` --- ```solidity=288 function symbol() public view virtual override returns (string memory) { ``` --- ```solidity=305 function decimals() public view virtual override returns (uint8) { ``` --- ```solidity=331 function transfer(address recipient, uint256 amount) public virtual override returns (bool) { ``` --- ```solidity=339 function allowance(address owner, address spender) public view virtual override returns (uint256) { ``` --- ```solidity=350 function approve(address spender, uint256 amount) public virtual override returns (bool) { ``` --- ```solidity=368 function transferFrom( ``` --- ```solidity=396 function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { ``` --- ```solidity=415 function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { ``` --- ```solidity=1264 function setAutomatedMarketMakerPair(address pair, bool value) ``` --- ```solidity=1295 function isExcludedFromFees(address account) public view returns (bool) { ```

The audit on Trustblock · Open the report
LowInconsistent Comment and CodeTHE Protocol ($THE) - Audit · CertiKOpen

The comment states `3% from total supply maxWallet`, however the `maxWallet` is actually set to 2%.

The audit on Trustblock · Open the report
LowMissing Emit EventsTHE Protocol ($THE) - Audit · CertiKOpen

There should always be events emitted in the sensitive functions that are controlled by centralization roles.

The audit on Trustblock · Open the report
LowPotential Sandwich AttacksTHE Protocol ($THE) - Audit · CertiKOpen

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 back running (after the transaction is attacked) a transaction to sell the asset. Potential sandwich attacks could happen in the below cases: - calling `uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens` and `uniswapV2Router.addLiquidityETH` without setting restrictions on slippage. - calling the `autoBurnLiquidityPairTokens()` function and the `manualBurnLiquidityPairTokens()` For example, when we want to make a transaction of swapping 100 `THE` for 1 ETH, an attacker could raise the price of ETH by adding `THE` into the pool before the transaction so we might only get 0.1 ETH. After the transaction, the attacker would be able to withdraw more than he deposited because the total value of the pool increases by 0.9 ETH.

The audit on Trustblock · Open the report
LowState Variable Should Be Declared ConstantTHE Protocol ($THE) - Audit · CertiKOpen

State variables that never change should be declared as `constant` to save gas. ```solidity=1048 uint256 public manualBurnFrequency = 30 minutes; ``` - `manualBurnFrequency` should be declared `constant`.

The audit on Trustblock · Open the report
LowTautology or ContradictionTHE Protocol ($THE) - Audit · CertiKOpen

The comparison, `_percent >= 0`, which is always true may be unnecessary. ```solidity=1537 require( _percent <= 1000 && _percent >= 0, "Must set auto LP burn percent between 0% and 10%" ); ```

The audit on Trustblock · Open the report
LowThird Party DependencyTHE Protocol ($THE) - 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 assume 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=1030 IUniswapV2Router02 public immutable uniswapV2Router; ``` - The contract `THEPROTOCOL` interacts with third party contract with `IUniswapV2Router02` interface via `uniswapV2Router`.

The audit on Trustblock · Open the report
LowUnnecessary Use of SafeMathTHE Protocol ($THE) - 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=591 library SafeMath { ``` - An implementation of `SafeMath` library is found. --- ```solidity=1028 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `THEPROTOCOL` contract. ```solidity=1418 fees = amount.mul(sellTotalFees).div(100); ``` - `SafeMath.mul` is called in `_transfer` function of `THEPROTOCOL` contract.

The audit on Trustblock · Open the report
LowUnused EventTHE Protocol ($THE) - Audit · CertiKOpen

```solidity=1083 event UpdateUniswapV2Router( address indexed newAddress, address indexed oldAddress ); ``` - `UpdateUniswapV2Router` is declared in `THEPROTOCOL` but never emitted. --- ```solidity=1299 event BoughtEarly(address indexed sniper); ``` - `BoughtEarly` is declared in `THEPROTOCOL` but never emitted.

The audit on Trustblock · Open the report
LowUnused Return ValueTHE Protocol ($THE) - Audit · CertiKOpen

Function **addLiquidity** [[*link*](https://etherscan.io/address/0x0cba60ca5ef4d42f92a5070a8fedd13be93e2861/THEPROTOCOL.sol#L1461)] from current project triggered expert rules derived from function **addLiquidity** [[*link*](https://bscscan.com/address/0xcb1ddc8f705e2737685a9c1e6b84a63d04d200e5#L769)] from project **DecentralizedUnited**. Here is the description text of a finding from that project that might be relevant. The return value of an external call is not stored in a local or state variable. ```solidity=769 uniswapV2Router.addLiquidityETH{value: ethAmount}( address(this), tokenAmount, 0, // slippage is unavoidable 0, // slippage is unavoidable deadWallet, block.timestamp ); ```

The audit on Trustblock · Open the report
LowWrong Denominator When Distributing ETHTHE Protocol ($THE) - Audit · CertiKOpen

The function `swapBack()` swaps part of the `THE` tokens of this contract for ETH, and uses the rest `THE` tokens of this contract to add the liquidity. ```solidity=1474 function swapBack() private { uint256 contractBalance = balanceOf(address(this)); uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing + tokensForDev; bool success; if (contractBalance == 0 || totalTokensToSwap == 0) { return; } if (contractBalance > swapTokensAtAmount * 20) { contractBalance = swapTokensAtAmount * 20; } // Halve the amount of liquidity tokens uint256 liquidityTokens = (contractBalance * tokensForLiquidity) / totalTokensToSwap / 2; uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens); uint256 initialETHBalance = address(this).balance; swapTokensForEth(amountToSwapForETH); uint256 ethBalance = address(this).balance.sub(initialETHBalance); uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div( totalTokensToSwap ); uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap); ``` The L1499 variable `ethBalance` is the amount of `ETH` which is exchanged in this transaction. `ethBalance` needs to be split into 3 parts, which include adding liquidity and distributing ETH to `tokensForMarketing` and `tokensForDev`. However, when calculating the corresponding ETH part, the dominator is wrong. For example: - `tokensForLiquidity` = 4, `tokensForMarketing` = 4, `tokensForDev` = 4, so the `totalTokensToSwap` = 12; - Then this contract sells (contractBalance * 10 / 12) of the `THE` tokens; - And the denominator in the calculation formula on L1501 and L1504 is `totalTokensToSwap`, which is equivalent to 12. It should be 10 that is the actual `THE` tokens are swapped for ETH. Thus, we think the denominator should be changed to `tokensForLiquidity/2 + tokensForMarketing + tokensForDev`.

The audit on Trustblock · Open the report
LowWrong Value is Emitted in `SwapAndLiquify` EventTHE Protocol ($THE) - Audit · CertiKOpen

In function `swapBack()`, event `SwapAndLiquify` is emitted mistakenly. The `tokensForLiquidity` is set to zero before emitting this event. It is falsely used in the event. ```solidity=1516 emit SwapAndLiquify( amountToSwapForETH, ethForLiquidity, tokensForLiquidity ); ```

The audit on Trustblock · Open the report

The THE Protocol security record · Every THE Protocol address · This address on the explorer