Datachain security record

BNB Chain, Ethereumdatachain.jp

As of 19 Nov 2026, Datachain has 7 audit reports by 1 security firm on Trustblock; the latest is by Quantstamp, dated 25 Jul 2025. Those reports list no open critical findings.

Critical findings
No open critical findings
Across 7 reports.
Open the latest report
Your label, live
Get the label for your site

Record last updated . It holds audits and findings, contracts and incidents up to Nov 2026. Trustblock does not review code.

Audits7

Newest first

ReportSecurity firmDateScopeCritical findingsSource
Datachain - ELC for Bridge (OptimismELC)Security firm: QuantstampDate: Scope: Not recorded; see the reportNone opencertificate.quantstamp.com ↗
Datachain LCP-zkDCAPSecurity firm: QuantstampDate: Scope: Files listedNone opencertificate.quantstamp.com ↗
Datachain - App for LiquiditySecurity firm: QuantstampDate: Scope: Repository at commit dcccb98None opencertificate.quantstamp.com ↗
Datachain - ELC for Bridge - EthereumSecurity firm: QuantstampDate: Scope: Repository at commit 7a40e6aNone opencertificate.quantstamp.com ↗
Datachain - ELC For Bridge - BSCSecurity firm: QuantstampDate: Scope: Repository at commit 78d1349None opencertificate.quantstamp.com ↗
Datachain - IBCSecurity firm: QuantstampDate: Scope: Repository at commit ca7a56cNone opencertificate.quantstamp.com ↗
Datachain - LCPsSecurity firm: QuantstampDate: Scope: Repository at commit 54d2bacNone opencertificate.quantstamp.com ↗

Findings65

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

SeverityOpenAcknowledgedFixedMitigated
Critical0000
High0170
Medium0171
Low02230

Marked Informational or Undetermined by the firms. Not counted as findings.

Informational**Rate Limiting Threshold Bypass**Datachain - App for Liquidity · Quantstamp · 27 Jan 2025Acknowledged

Current implementation only tracks transfers above `THRESHOLD`, allowing rate limit bypass through multiple smaller transfers. Allowing unlimited transfers below threshold. **Current Code**: ```solidity if (THRESHOLD < amount) { $._cancellableAmount = amount; $._currentPeriodAmount += amount; } else { $._cancellableAmount = 0; } ```

Open the report
InformationalRace Condition for `refuelDstCap`Datachain - App for Liquidity · Quantstamp · 27 Jan 2025Acknowledged

The `refuelAmount` is capped once received by the destination chain. The source chain validates that the `refuelAmount` is within bounds before sending out the message. However, the `refuelDstCap` can be updated at any time in `BridgeManager.setRefuelCap()`. If the chains fuel caps are ever desynchronized, a user may not have their full refuel amount transferred to them and the difference will be kept by the protocol.

Open the report
InformationalMissing Validation for Finalized Header in Light ClientDatachain - ELC for Bridge - Ethereum · Quantstamp · 8 Jan 2025Acknowledged

The function `is_valid_light_client_finalized_header()` is missing essential validation checks for finalized headers introduced in the Deneb (EIP-4844) and Capella upgrades. These checks ensure that: - For epochs earlier than `DENEB_FORK_EPOCH`, `execution.blob_gas_used` and `execution.excess_blob_gas` are both `0`. - For epochs earlier than `CAPELLA_FORK_EPOCH`, `execution` is an empty `ExecutionPayloadHeader`, and `execution_branch` is an empty `ExecutionBranch`. These validations are specified in the [Deneb upgrade to the Sync Protocol](https://github.com/ethereum/consensus-specs/blob/dev/specs/deneb/light-client/sync-protocol.md#modified-is_valid_light_client_header). Without these validations, the function may incorrectly validate headers that are non-compliant with the protocol rules for these upgrades.

Open the report
Informational`channelCloseConfirm()` Does Not Delete Upgrade Paths of the Channel Being ClosedDatachain - IBC · Quantstamp · 21 Nov 2024Acknowledged

[The specs](https://github.com/cosmos/ibc/blob/499818e9c4b136029717a436a04af15113f4424f/spec/core/ics-004-channel-and-packet-semantics/README.md?plain=1#L588) describe that in `channelCloseConfirm()` any upgrade stored at the channel upgrade path should be deleted during this process, however there is no deletion taking place.

Open the report
InformationalDeviations From ICS-SpecsDatachain - IBC · Quantstamp · 21 Nov 2024Acknowledged

Below, we include a non-exhaustive list of all deviations from the ICS-Specs in the ibc-solidity implementatio. These deviations are not standalone issues, however we list these deviations for transparency for all future users of ibc-solidity. Many of these deviations are a result of the limitations of the Solidity language and the EVM environment, such as gas costs or transaction gas limits and are intentional design decisions made by the Datachain team. The team has documented these changes in the files at `docs/adr`. Overall, we note that ibc-solidity does not support multi-hop connections or for the `ORDERED_ALLOW_TIMEOUT` channel ordering mechanism, as described in the ICS-Specs. Therefore, all logic associated with that is not present in the ibc-solidity implementation. Deviations: - `authenticateCapability()` does not exist in the ibc-solidity implementation as a single function, as described in the ICS specs. Instead, the owner of the `IBCHandler` contract will invoke `bindPort()` to assign module address to given ports in the provable store of the `IBCHandler`. Then, throughout conneciton and channel handshakes, capabilities are authenticated through functions such as `IBCModuleManager.lookupModuleByPort()` and `lookupModuleByChannel()`, which proves there is a non-zero address mapped at the port or channel, showing that the module has been bound by an IBC admin, and the channel has been written. During handshakes, module callback functions such as `onRecvPacket()` will only be invoked on the module addresses assigned by the Admin. - `clientConnectionsPath()` providing a reverse mapping from clients to a set of connections is not included in the implementation. - This means, there is no way that `queryClientConnections()` can be implemented and this data will have to be queried using other methods. - `ConnectionEnd` structural deviation: - `delayPeriodBlocks` is not defined to be a field within a Connection. Instead, when this field is needed for message passing, it is calculated during the transaction, as a function of the `delayPeriodTime` and the `expectedTimePerBlock` which is configurable by the IBCHandler admin. - Further, the `ConnectionEnd` doesn't have fields like `counterPartyPrefix` and instead, these fields are defined within a counterparty data structure which is a field within the ConnectionEnd itself - `channelOpenInit()` & `channelOpenTry()` do not confirm that the generated `channelId` is not already stored, as specified in the specs. We recognize that a clash is highly unlikely, as there are 2^64 possible ids. However, a check like this is done in `connectionOpenInit()` and we recommend verifying that there is nothing stored at the generated id for thoroughness. - `emit RecvPacket()` does not include the Order and Connection fields as [specified in ICS-specs](https://github.com/cosmos/ibc/blob/499818e9c4b136029717a436a04af15113f4424f/spec/core/ics-004-channel-and-packet-semantics/README.md?plain=1#L879) - the `_writeAcknowledgement()` function is emitting an event that is missing the following fields, that are otherwise specified in the specs: - `timeoutHeight` - `timeoutTimestamp` - `packet.data` - `sendPacket()` does not check that the connection exists. However, since the connection is stored within the `Channel.Data` itself, and the channel's existence is confirmed, we see no major issue here and include this to note the discrepancy. - Specs allow for a packet to received more than once, with just an identical event being emitted, however, in the implementation, we cannot receive a packet more than once, and the transaction will revert. the Datachain team has already acknowledged this to be a design choice however we note here for thoroughness and transparency. - `counterpartyUpgradePaths()` are not written to the provable store

Open the report
InformationalDuplicate Values Are Not Checked in `try_from()` for `MemoryOracleClient`Datachain - ELC for Bridge (OptimismELC) · Quantstamp · 25 Jul 2025Fixed

The `try_from()` function implemented for `MemoryOracleClient` loops on the `value` vector of preimages. The logic does not validate for duplicate preimages before operating on them, which may result in unwanted or broken behavior.

Open the report
InformationalGlobal Generic and Local Keytypes Are AllowedDatachain - ELC for Bridge (OptimismELC) · Quantstamp · 25 Jul 2025Fixed

The `try_from()` function implemented for `MemoryOracleClient` matches the `preimage_key.key_type()` value against the `PreimageKeyType::Keccak256` and `PreimageKeyType::Sha256` keytypes to validate them before including them in the oracle; however, the `_ => {}` arm would allow any other keytype to be included in the oracle without validation.

Open the report
InformationalMisbehaviour Handling Not ImplementedDatachain - ELC for Bridge (OptimismELC) · Quantstamp · 25 Jul 2025Fixed

The `update_client()` function has a `todo!()` for `ClientMessage::Misbehaviour`. Hence, the light client cannot currently process or react to misbehaviour reports.

Open the report
InformationalNondeterministic `verify_blob_preimage()`Datachain - ELC for Bridge (OptimismELC) · Quantstamp · 25 Jul 2025Fixed

Currently, when calling `verify_blob_preimage()`, the value of the last 32 bytes of `blob_key` when instantiated at `oracle.rs#L176` can in principle be arbitrary so long as the commitment within the first 48 bytes is correct. Although the function remains safe due to KZG verification, it may cause the client to accept preimages that other clients would reject, resulting in a subtle impact regarding client interoperability.

Open the report
InformationalInconsistent Expiration Validation Logic for `validityNotAfter`Datachain LCP-zkDCAP · Quantstamp · 27 Mar 2025Fixed

The logic used to validate the expiration of enclave keys in the `LCPClientZKDCAPBase.zkDCAPRegisterEnclaveKey()` function exhibits inconsistent behavior when `block.timestamp == output.validityNotAfter`. Specifically, the current implementation allows this edge case to pass when `key_expiration == 0`, but triggers a revert when `key_expiration != 0`. This inconsistency may lead to unexpected or confusing behavior for integrators or future auditors of the code. Although this is an edge case and would only cause a transient error, ensuring consistent validation logic is important for clarity and maintainability.

Open the report
Show 10 more
InformationalUpgradeable Contracts Should Call `_disableInitializers()`Datachain LCP-zkDCAP · Quantstamp · 27 Mar 2025Fixed

The upgradeable contracts `LCPClientIASOwnableUpgradeable` and `LCPClientZKDCAPOwnableUpgradeable` allow an attacker to initialize the implementation contract, which could lead to phishing and social engineering attacks. For more details, see the [OpenZeppelin guideline](https://docs.openzeppelin.com/upgrades-plugins/writing-upgradeable#initializing_the_implementation_contract).

Open the report
InformationalArbitrage Is Only Prohibited For Negative Price DriftDatachain - App for Liquidity · Quantstamp · 27 Jan 2025Fixed

The `getDriftProtocolFee()` is intended to eliminate any profits that might be made from token arbitrage. If `srcPrice < dstPrice`, it will charge the user any profits made from the arbitrage as a fee. Otherwise it will return a fee of zero. However, if the `srcStatus == IStableTokenPriceOracle.PriceDeviationStatus.Normal`, then a fee of zero is returned regardless of whether an arbitrage opportunity exists. If the `dstPrice` has an upwards depeg such that it is worth more than the pegged `srcPrice` (such as $1.01), then an arbitraged trade is possible. While price depegs in the upwards direction tend to repeg quickly, it is important to consider how rapid fluctuations in liquidity affect the protocol.

Open the report
UndeterminedInaccurate balance checkDatachain - App for Liquidity · Quantstamp · 27 Jan 2025Fixed

As described by the delta algorithm, the `Pool.transfer()` function will check that there is sufficient balance in the destination pool before executing a transfer. However, the balance check does not match the balance decremented on receival: ``` // Pool.transfer() feeInfo.lastKnownBalance = amountGD - feeInfo.lpFee + feeInfo.eqReward; if (peerPoolInfo.balance < amountGD) { revert TokiInsufficientPoolLiquidity( peerPoolInfo.balance, amountGD ); } // Pool.recv() peerPoolInfo.lastKnownBalance = peerPoolInfo.lastKnownBalance - feeInfo.lastKnownBalance; ``` If `feeInfo.lpFee > feeInfo.eqReward`, it is possible that the transfer will overdraft and revert due to underflow on the receiving side, thereby breaking the guarantee of finality.

Open the report
InformationalUnbounded Loop in `_deltaSourceUpdate` Leads to Potential Denial-of-Service (Dos) AttackDatachain - App for Liquidity · Quantstamp · 27 Jan 2025Fixed

The `_deltaSourceUpdate()` function in `Pool.sol` contains a loop that iterates over all entries in the `_peerPoolInfos` array. The number of iterations of this loop is not bounded by any constant or configuration parameter. If the number of peer pools grows large, this loop could consume excessive gas, potentially leading to out-of-gas errors and a denial-of-service (DoS) condition. **Specifically, the following loops are affected:** ```solidity for (uint256 i = 0; i < peerPoolInfosLength; ++i) { ... } ```

Open the report
InformationalUndisabled initializers within upgradeable contract implementationDatachain - App for Liquidity · Quantstamp · 27 Jan 2025Fixed

The constructors of implementation contracts fail to call the `_disableInitializers()` function, leaving the contracts vulnerable to unexpected initialization outside the proxy.

Open the report
InformationalUnprotected `reinitializer` functionDatachain - App for Liquidity · Quantstamp · 27 Jan 2025Fixed

The `RecoveredLCPClientUpgradeable.upgrade()` is an unprotected `reinitializer` function that can be exploited in protocol takeover scenarios.

Open the report
InformationalUsage of the transfer function can lead to unexpected future behaviorDatachain - App for Liquidity · Quantstamp · 27 Jan 2025Fixed

Relying on `address.transfer()` in Solidity for a reentrancy-free transfer of funds can lead to unexpected failed calls. The gas cost of different opcodes has been adjusted before and can be adjusted again, which may create unforeseen side effects.

Open the report
InformationalNot Taking Update's Next Sync CommitteeDatachain - ELC for Bridge - Ethereum · Quantstamp · 8 Jan 2025Fixed

The function `apply_updates()` is designed to mirror the function of the spec named `apply_light_client_update()`. In the latter function, when the stored consensus state lacks a next sync committee, it is checked that the update's finalized header's sync committee period is equal to the stored consensus state's sync committee period, and the update's next sync committee is added to the stored consensus state. However, this assignment does not take place at any point in `apply_updates()`. However, this appears not to be a problematic issue as it appears that the stored consensus state will never be lacking a next sync committee. This is despite the fact that when the new consensus state is validated in `ConsensusState::validate()`, it is not checked whether there is a next sync committee.

Open the report
InformationalNot All Sequence Variables Are Stored in the Provable StoreDatachain - IBC · Quantstamp · 21 Nov 2024Fixed

The function `initializeSequences()` sets initial values in `channelStorage` for `nextSequenceSend`, `nextSequenceRecv`, and `nextSequenceAck`. However, only `nextSequenceRecv` is stored directly in the provable store: ``` getCommitments()[IBCCommitment.nextSequenceRecvCommitmentKey(portId, channelId)] = keccak256(abi.encodePacked((bytes8(uint64(1))))); ``` The [ICS-024 specification](https://github.com/cosmos/ibc/blob/47fea20d4d400e967721396092c6b43398c65d78/spec/core/ics-024-host-requirements/README.md#path-space) suggests that all three should be committed to the provable store.

Open the report
InformationalPotential Arbitrary Calls in `updateClient()`Datachain - IBC · Quantstamp · 21 Nov 2024Fixed

In `IBCClient.updateClient()`, there is the possibilitiy for a light client supporting arbitrary function calls, in the case where the call to `lc.routeUpdateClient()` were to return an unexpected function selector that would then be invoked on the Light Client itself. The Datachain team has already noted this situation in documentation ADR-001 however we include it here for clarity. There, they mention that this can be mitigated at the relayer level, by relayers including a whitelist of expected functions. Additionally, we trust that the light clients are implemented honestly to not support arbitrary calls.

Open the report
Show 3 more
InformationalValidator Does Not Check for Suggested Identifier Size RestrictionsDatachain - IBC · Quantstamp · 21 Nov 2024Fixed

The table in [ICS-024](https://github.com/cosmos/ibc/blob/47fea20d4d400e967721396092c6b43398c65d78/spec/core/ics-024-host-requirements/README.md#paths-identifiers-separators) suggests that a client identifier should be between 9-64 characters, however no such check occurs in `validateClientType()`. Note that `validatePortIdentifier()` does include checks for the suggested length.

Open the report
InformationalConsider Using `rand::rndg::OsRng` for More RobustnessDatachain - LCPs · Quantstamp · 12 Nov 2024Fixed

The function `get_quote()` in `ias_utils.rs` uses `rand::thread_rng()` which provides a pseudorandom value in each thread independently which might not be as robust or secure as desired.

Open the report
InformationalEnclave Leaking Panic ContentsDatachain - LCPs · Quantstamp · 12 Nov 2024Fixed

The panic handler added to this forked crate makes use of `ocall` to pass panic information outside of the enclave, simply forwarding the info associated with the panic.

Open the report

Contracts

No deployed address is recorded for these audits.

The reports name a repository or files. Open a report to see its scope.

The repositories and files the reports name

Show this on your site

Is this your project? Show this record on your own website. The label states what the record holds, links to this page and updates by itself. It is free and needs no sign-in.

Content

Facts

Automatic: the three strongest facts of this project’s own record (its last audit and two more), highlighted. They update with the record. Picking a fact turns Automatic off.

Fixed as
Language

Style

Layout
Theme
Accent
Corners

Format

Size
Date
Embed as
HTML
<head>
<script src="https://widget.trustblock.run/project-widget.min.js" defer></script>
</head>
<body>
<div
data-tb-project-widget
data-tb-project-slug="datachain"
></div>
</body>

Paste the code where the label should appear. It uses no API credit and updates by itself.

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