Status DataClose notification

Overlayer Disclosed Report

Audit Report

Live EURS+ Sepolia -> Optimism Sepolia bridge permanently locks user funds because non-hub receive underflows bridge accounting

Target

Target is hidden

This information is not publicly available.

Vulnerability details

Summary

A live EURS+ bridge path can permanently lock end-user funds because the non-hub receive logic uses vulnerable bridge accounting.

The root cause is the bridge accounting logic in the scoped OverlayerWrapCore implementation; AaveHandler is relevant because the hub-side backing invariant relies on totalSupply() + totalBridgedOut.

This is critical because OFT burns the user’s balance on the source chain before the destination-side credit finishes. As a result, the user can lose source-side EURS+ and receive nothing on the destination chain.

Affected source files

  • contracts/overlayer/OverlayerWrapCore.sol
  • contracts/overlayerbacking/AaveHandler.sol

Live affected deployment

Ethereum Sepolia hub

  • EURS+: 0x919CbEEce48DE3f3FA1Ec8837d461cB7Dd8F97a6

Optimism Sepolia non-hub peer

  • EURS+: 0xfd0E0c5132B1C0C59A413e52f97BC421592Ba460

Root cause

The vulnerable bridge logic is:

function _debit(...) internal virtual override returns (...) {
    (amountSentLD, amountReceivedLD) = super._debit(...);
    totalBridgedOut += amountSentLD;
}

function _credit(...) internal virtual override returns (uint256 amountReceivedLD) {
    amountReceivedLD = super._credit(to_, amountLD_, srcEid_);
    totalBridgedOut -= amountReceivedLD;
}

This accounting only makes sense on the hub chain, where backing logic reasons over:

totalSupply() + totalBridgedOut

That intent is visible in AaveHandler.supply().

The problem is that the same accounting is applied on non-hub deployments. On the non-hub deployment, totalBridgedOut is a local variable that was never incremented for the incoming bridge transfer. Therefore, the first inbound _credit() can execute:

totalBridgedOut -= amountReceivedLD;

with local 'totalBridgedOut == 0', causing an arithmetic underflow and reverting the receive path.

Impact This causes permanent lock of bridged end-user funds.

Normal user flow:

1.The user holds EURS+ on Ethereum Sepolia. 2.The user bridges EURS+ to Optimism Sepolia. 3.The source-side OFT debit burns the user’s Sepolia balance. 4.The destination-side receive executes _credit(). 5.The destination-side runtime underflows local totalBridgedOut and reverts. 6.The user no longer has the source-side tokens and does not receive destination-side tokens. This is not an informational issue, not a best-practice issue, and not a theoretical issue. It is a direct permanent-lock condition on a live bridge path.

Live evidence I verified the live deployment path on April 7, 2026:

1.Sepolia hub peers(40232) points to 0xfd0E0c5132B1C0C59A413e52f97BC421592Ba460 2.Optimism Sepolia peer peers(40161) points back to 0x919CbEEce48DE3f3FA1Ec8837d461cB7Dd8F97a6 3.both deployed runtimes revert on totalBridgedOut(), which shows the mitigation is not present in the live bridge runtime

Suggested fix Restrict totalBridgedOut mutations to the hub chain only:

function _debit(...) internal virtual override returns (...) {
    (amountSentLD, amountReceivedLD) = super._debit(...);
    if (block.chainid == hubChainId) {
        totalBridgedOut += amountSentLD;
    }
}

function _credit(...) internal virtual override returns (uint256 amountReceivedLD) {
    amountReceivedLD = super._credit(to_, amountLD_, srcEid_);
    if (block.chainid == hubChainId) {
        totalBridgedOut -= amountReceivedLD;
    }
}

This preserves the hub-side backing invariant and prevents invalid subtraction on non-hub receives.

Validation steps

Validation steps

I validated this issue in 2 separate ways:

  1. a runnable local PoC that proves the exact failure mode
  2. a live on-chain check that proves the current EURS+ bridge topology exists

Part 1: Run the local PoC

Step 1

Open the repository root:

cd "D:\Overlayer SC DualDefense Audit\repo"

Step 2

Run the vulnerable bridge PoC:

npx.cmd hardhat test --config hardhat.audit.config.ts test\poc-totalBridgedOut-credit-lock.vuln.ts

Step 3

Expected result:

PoC: vulnerable cross-chain receive accounting
  √ burns on hub and reverts on the first inbound receive to a non-hub deployment
  √ shows the patched implementation accepts the same inbound receive path

2 passing

What this PoC proves

The PoC file is:

  • test/poc-totalBridgedOut-credit-lock.vuln.ts It proves the following sequence:

1.A user mints tokens on the hub instance. 2.The hub-side bridge debit succeeds. 3.The hub-side balance is burned. 4.The vulnerable non-hub receive reverts with arithmetic panic 0x11. 5.The destination user receives zero tokens. 6.The patched implementation accepts the same inbound receive path. This is important because it proves the bug is not informational. It is a real burn-then-credit-revert fund-lock path.

Part 2: Verify the live deployment path

Step 4

Run the live deployment checker:

node scripts/audit/check-live-eurs-bridge-lock.js

Step 5

Expected result:

{
  "dateUtc": "2026-04-07T14:21:38.557Z",
  "hubWrap": "0x919CbEEce48DE3f3FA1Ec8837d461cB7Dd8F97a6",
  "opWrap": "0xfd0E0c5132B1C0C59A413e52f97BC421592Ba460",
  "hubName": "Eurs+",
  "hubSymbol": "EURS+",
  "hubTotalSupply": "51459150000000000000000",
  "hubChainId": "11155111",
  "hubSpender": "0xea4b282d053277c08684199d9fcb524A60EB5e6e",
  "hubPeerToOp": "0x000000000000000000000000fd0e0c5132b1c0c59a413e52f97bc421592ba460",
  "hubTotalBridgedOut": "execution reverted (no data present; likely require(false) occurred",
  "opName": "Eurs+",
  "opSymbol": "EURS+",
  "opTotalSupply": "0",
  "opChainId": "11155111",
  "opPeerToHub": "0x000000000000000000000000919cbeece48de3f3fa1ec8837d461cb7dd8f97a6",
  "opTotalBridgedOut": "execution reverted (no data present; likely require(false) occurred"
}

What this live check proves

The checker file is:

  • scripts/audit/check-live-eurs-bridge-lock.js It proves all of the following:

1.The live Sepolia hub EURS+ contract exists. 2.The live Optimism Sepolia peer EURS+ contract exists. 3.The bridge peers are configured in both directions. 4.The live Sepolia hub currently has 51459.15 EURS+ supply. 5.Both runtimes revert on totalBridgedOut(), which shows the live bridge runtime still does not include the mitigation.

Final validation conclusion This issue is validated by both:

local execution proof of the actual vulnerable bridge behavior live on-chain proof that the affected bridge topology is currently deployed The bug causes permanent lock of end-user bridged funds and is therefore critical.

Attachments

Attachments are hidden

This information is not publicly available.

Comments are hidden

This information is not publicly available.