RisingCoin contract 0x932d…d26a on BNB Chain

0x932d73dccdb2a6b4f06fd8436f29e42cae33d26a

As of 21 Nov 2026, Trustblock’s record holds 0x932d73dccdb2a6b4f06fd8436f29e42cae33d26a on BNB Chain as a contract of RisingCoin. 1 audit report on Trustblock lists this address: CertiK, 21 Nov 2022. 23 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
RISC(RisingCoin)CertiKNot recorded (see the report)Open

Open and acknowledged findings in these reports23

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

HighContract Gains Non-Withdrawable BNB via the `swapRISC(RisingCoin) · CertiKAcknowledged

The `swapAndLiquify` function converts half of the amount of tokens to BNB. The other half of the tokens and part of the converted BNB are deposited into the pair on DEX as liquidity. For every `swapAndLiquify` function call, a small amount of BNB is leftover in the contract. This is because the price of tokens drops after swapping the first half of tokens into BNBs, and the other half of tokens require less than the converted BNB to be paired with it when adding liquidity. The contract doesn't appear to provide a way to withdraw those BNB, and they will be locked in the contract forever.

The audit on Trustblock · Open the report
HighInitial Token DistributionRISC(RisingCoin) · CertiKAcknowledged

All **RISC** tokens are sent to the contract deployer when deploying the contract. This is a potential centralization risk as the deployer can distribute **RISC** tokens without the consensus of the community.

The audit on Trustblock · Open the report
LowFunction Initializing StateRISC(RisingCoin) · CertiKOpen

State variables are inline initialized using either non-constant state variables or function calls that are not pure/constant. Since inline initialization occurs before the constructor call, some non-constant state variables may not be initialized and non-constant functions may behave in an unexpected way. ```solidity=426 uint256 private _totalSupply = 100000000 * 10**_decimals; uint256 public _maxTxAmount =100000000* 10**_decimals; uint256 public _walletMax = 100000000 * 10**_decimals; uint256 private minimumTokensBeforeSwap = 100 * 10**_decimals; ```

The audit on Trustblock · Open the report
LowFunctions Can Be Declared `external`RISC(RisingCoin) · CertiKOpen

`public` functions that are never called by the contract could be declared as `external`.

The audit on Trustblock · Open the report
LowLack of Input ValidationRISC(RisingCoin) · CertiKOpen

The values functions which are used to change the values of `_totalTaxIfBuying`,`_totalTaxIfSelling` and `_totalDistributionShares` lack input validation to ensure these values do not exceed 100.

The audit on Trustblock · Open the report
LowMissing Emit EventsRISC(RisingCoin) · CertiKOpen

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

The audit on Trustblock · Open the report
LowMissing Error MessagesRISC(RisingCoin) · CertiKOpen

The **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 report
LowMissing Zero Address ValidationRISC(RisingCoin) · CertiKOpen

Addresses should be checked before assignment or external call to make sure they are not zero addresses. ```solidity=600 marketingWalletAddress = payable(newAddress); ``` - `newAddress` is not zero-checked before being used. --- ```solidity=604 teamWalletAddress = payable(newAddress); ``` - `newAddress` is not zero-checked before being used.

The audit on Trustblock · Open the report
LowPotential Sandwich AttacksRISC(RisingCoin) · 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 being attacked) a transaction to sell the asset. The `swapExactTokensForETHSupportingFeeOnTransferTokens()` and `addLiquidityETH()` functions are called without setting restrictions on slippage or minimum output amount, so transactions triggering these functions are vulnerable to sandwich attacks.

The audit on Trustblock · Open the report
LowPrivilege not Revoked or TransferredRISC(RisingCoin) · CertiKOpen

The owner is exempt from fees and transaction limits by default. Yet, when ownership is reset through `renounceOwnership()` or `transferOwnership()`, the exemptions are not granted to the new owner, nor are they revoked from the previous owner. Similarly, upon changing the router address using `changeRouterVersion()`, the old router address will still be exempt from fees and the wallet limit, and will still have an allowance.

The audit on Trustblock · Open the report
LowPull-Over-Push Pattern In `transferOwnership()` FRISC(RisingCoin) · CertiKOpen

The change of `_owner` by function `transferOwnership()` overrides the previously set `_owner` with the new one without guaranteeing the new `_owner` is able to actuate transactions on-chain.

The audit on Trustblock · Open the report
LowRedundant CheckRISC(RisingCoin) · CertiKOpen

The linked **if** statement checks if `inSwapAndLiquify` is false, however, this check is redundant because the only way to reach this **if** block is if it fails the first one, therefore `inSwapAndLiquify` must be false here.

The audit on Trustblock · Open the report
LowState Variable Should Be Declared `constant`RISC(RisingCoin) · CertiKOpen

State variables that never change should be declared as `constant` to save gas.

The audit on Trustblock · Open the report
LowThird Party DependencyRISC(RisingCoin) · 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=431 IUniswapV2Router02 public uniswapV2Router; ``` - The contract `RisingCoin` interacts with third-party contract with `IUniswapV2Router02` interface via `uniswapV2Router`.

The audit on Trustblock · Open the report
LowToo Many DigitsRISC(RisingCoin) · CertiKOpen

Literals with many digits are difficult to read and review. ```solidity=426 uint256 private _totalSupply = 100000000 * 10**_decimals; uint256 public _maxTxAmount =100000000* 10**_decimals; uint256 public _walletMax = 100000000 * 10**_decimals; ```

The audit on Trustblock · Open the report
LowTypoRISC(RisingCoin) · CertiKOpen

The linked function is misspelled and should be changed to `setSellTaxes()`.

The audit on Trustblock · Open the report
LowUnnecessary Use of SafeMathRISC(RisingCoin) · 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.

The audit on Trustblock · Open the report
LowUnused ContractRISC(RisingCoin) · CertiKOpen

```solidity=392 using Address for address; ``` - The library `Address` is declared on a using-for directive in `RisingCoin` but its functionalities are never used.

The audit on Trustblock · Open the report
LowUnused EventRISC(RisingCoin) · CertiKOpen

```solidity=440 event SwapAndLiquify( uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity ); ``` - `SwapAndLiquify` is declared in `RisingCoin` but never emitted. --- ```solidity=446 event SwapETHForTokens( uint256 amountIn, address[] path ); ``` - `SwapETHForTokens` is declared in `RisingCoin` but never emitted.

The audit on Trustblock · Open the report
LowUnused InterfaceRISC(RisingCoin) · CertiKOpen

```solidity=205 interface IUniswapV2Pair { ``` - `IUniswapV2Pair` is declared but never used.

The audit on Trustblock · Open the report
LowUnused Return ValueRISC(RisingCoin) · CertiKOpen

The return value of an external call is not stored in a local or state variable. ```solidity=753 uniswapV2Router.addLiquidityETH{value: ethAmount}( address(this), tokenAmount, 0, // slippage is unavoidable 0, // slippage is unavoidable owner(), block.timestamp ); ```

The audit on Trustblock · Open the report
LowUnused State VariableRISC(RisingCoin) · CertiKOpen

One or more state variables are never used in the codebase. Variable `asdasd` in `Ownable` is never used in `RisingCoin`. ```solidity=152 address private asdasd; ``` ```solidity=389 contract RisingCoin is Context, IERC20, Ownable { ``` --- Variable `_lockTime` in `Ownable` is never used in `RisingCoin`. ```solidity=153 uint256 private _lockTime; ``` ```solidity=389 contract RisingCoin is Context, IERC20, Ownable { ```

The audit on Trustblock · Open the report
LowUsage of `transfer`/`send` for sending EtherRISC(RisingCoin) · CertiKOpen

It is not recommended to use Solidity's `transfer()` and `send()` functions for transferring Ether, since some contracts may not be able to receive the funds. Those functions forward only a fixed amount of gas (2300 specifically) and the receiving contracts may run out of gas before finishing the transfer. Also, EVM instructions' gas costs may increase in the future. Thus, some contracts that can receive now may stop working in the future due to the gas limitation. ```solidity=621 recipient.transfer(amount); ``` - `RisingCoin.transferToAddressETH` uses `transfer()`.

The audit on Trustblock · Open the report

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