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.
Each report’s scope as stored on Trustblock names this address on BNB Chain.
| Audit | Security firm | Date | Commit named in the report | Report |
|---|---|---|---|---|
| RISC(RisingCoin) | CertiK | Not recorded (see the report) | Open |
2 High, 21 Low. In the firm’s own words; statuses are the firm’s, from each report.
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 reportAll **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 reportState 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`public` functions that are never called by the contract could be declared as `external`.
The audit on Trustblock · Open the reportThe 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 reportThere should always be events emitted in the sensitive functions that are controlled by centralization roles.
The audit on Trustblock · Open the reportThe **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 reportAddresses 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 reportA 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 reportThe 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 reportThe 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 reportThe 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 reportState variables that never change should be declared as `constant` to save gas.
The audit on Trustblock · Open the reportThe 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 reportLiterals 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 reportThe linked function is misspelled and should be changed to `setSellTaxes()`.
The audit on Trustblock · Open the reportThe `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```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```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```solidity=205 interface IUniswapV2Pair { ``` - `IUniswapV2Pair` is declared but never used.
The audit on Trustblock · Open the reportThe 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 reportOne 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 reportIt 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 reportThe RisingCoin security record · Every RisingCoin address · This address on the explorer