Crebit

CertiK1 address on BNB Chain

CertiK reviewed Crebit on 24 May 2024: 7 findings, 0 critical; 2 acknowledged, 5 open.

No open critical findings
Open the reportOpen Crebit’s security record

Report hosted on skynet.certik.com.

Trustblock does not review code.

Findings7

Statuses are the security firm’s own, from its report.

SeverityOpenAcknowledgedFixed
Critical000
High020
Medium000
Low500
LowDivision before Multiplication may Lead to Loss oOpen

Solidity integer division might truncate. As a result, performing multiplication before division can sometimes avoid loss of precision. This has minimal impact because that dust of assets will be sent in the last round of release in `releaseTimeLock()` function

LowInefficient Memory ParameterOpen

One or more parameters with `memory` data location are never modified in their functions and those functions are never called internally within the contract. Thus, their data location can be changed to `calldata` to avoid the gas consumption copying from calldata to memory. ```solidity=181 function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { ``` `approveAndCall` has memory location parameters: `_extraData`.

LowPotential Reentrancy IssueOpen

A reentrancy issue can occur when the contract creates a function that makes an external call to another untrusted contract before resolving any effects. If the attacker can control the untrusted contract, i.e. `_spender` in function `approveAndCall()`, they can make a recursive call back to other functions, repeating interactions that would have otherwise not run after the external call resolved the effects.

LowState Variable Should Be Declared ConstantOpen

State variables that never change should be declared as `constant` to save gas. ```solidity=101 uint128 internal MONTH = 30 * 24 * 3600; // 1 month ``` - `MONTH` should be declared `constant`.

LowVariables That Could Be Declared as ImmutableOpen

```solidity=113 uint8 public decimals; uint256 internal initialSupply; ``` The above variables assigned in the constructor can be declared as `immutable`. Immutable state variables can be assigned during contract creation but will remain constant throughout the lifetime of a deployed contract. A big advantage of immutable variables is that reading them is significantly cheaper than reading from regular state variables since they will not be stored in storage.

Contracts in scope1

AddressChainSource code
0x92b0e13f1c6bf5696289863ebc49a4f0bce46f3eChain: BNB ChainSource code: Verified source

Part of Crebit’s security record

Crebit
Audits1 audit by 1 firmLast audit May 2024, by CertiK.
Critical findingsNo open critical findingsIn 1 report.
Open Crebit’s security record

Security firm

CertiK

1,045 projects reviewed · 1,376 reports · latest May 2025

See CertiK’s audits

Something wrong on this page? A missing report, a wrong date, a finding that was fixed since. Tell us and we check it against its source.

Tell us