VegaSec / Solidity scan report

FallbackOracle.sol

VSS-20261004-81X07Y84 · generated Oct 4, 2026, 12:36 AM

Strong surface · automated2 findingsEtherscan verified1 warningsemgrep 1.163.0

Verdict is derived from severity counts via the same deterministic formula every VegaSec report uses. FallbackOracle.sol was scanned from etherscan verified. This is static-analysis triage, not a certification or formal audit attestation.

Signature

signed

This report is signed. Anyone can verify that these exact bytes came from us, with no account, no wallet and no API key. The signature proves integrity and authorship. It does not prove the audited contract is safe: read the coverage status and the limitations above.

sha256
ae65927deff1d2a0...cfffae9d
Signed by
Ed25519 key vsig-2026-09
Canonical version
vss-canonical-1
Bytes served
stored canonical text, byte for byte

PDF artifact

Queued artifact pipeline · not blocking on the scan

Not requested

No PDF artifact has been requested for this report yet. The HTML report and the Markdown export already carry the full disclaimer and limitations inline. PDF synthesis is a queued artifact, not part of the scan path.

Status endpoint

GET /report/solidity/VSS-20261004-81X07Y84/export.pdf

Solidity evidence report

2 audit findings

critical: 0high: 0medium: 0low: 0informational: 2

Severity distribution

Executive summary

  • 2 findings surfaced (0 critical, 0 high, 0 medium, 0 low, 2 informational).
  • Automated static analysis only. A human operator review has not been attached to this report.

Warnings (1)

  • · Unmapped detector slither:dead-code — classified as 'other'
semgrep 1.163.0
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    Version constraint ^0.8.0 contains known severe issues (https://solidity.readthedocs.io/en/latest/bugs.html)

    Affected location
    FallbackOracle.sol:8 · ^0.8.0
    Detector / source
    slither · slither:solc-version

    Evidence

    Version constraint ^0.8.0 contains known severe issues (https://solidity.readthedocs.io/en/latest/bugs.html) - FullInlinerNonExpressionSplitArgumentEvaluationOrder - MissingSideEffectsOnSelectorAccess - AbiReencodingHeadOverflowWithStaticArrayCleanup - DirtyBytesArrayToStorage - DataLocationChangeInInternalOverride - NestedCalldataArrayAbiReencodingSizeValidation - SignedImmutables - ABIDecodeTwoDimensionalArrayMemory - KeccakCaching. It is used by: - ^0.8.0 (FallbackOracle.sol#8) - ^0.8.0 (FallbackOracle.sol#36) - ^0.8.0 (FallbackOracle.sol#119) - ^0.8.0 (FallbackOracle.sol#129) - ^0.8.0 (FallbackOracle.sol#139)

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalOtherConfidence: mediumExploitability: lowDetector: slither

    Context._msgData() (FallbackOracle.sol#25-27) is never used and should be removed

    Affected location
    FallbackOracle.sol:25-27 · _msgData
    Detector / source
    slither · slither:dead-code

    Evidence

    Context._msgData() (FallbackOracle.sol#25-27) is never used and should be removed

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Review the detector output against the source manually; if exploitable, design a fix and add a regression test before deploying.

    Limitations

    • Medium analyzer confidence; manual review should confirm the code path and preconditions.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.

Limitations

  • VegaSec runs static analysis only. Findings can include false positives, miss patterns the configured detectors do not cover, and never replace manual auditor judgement.
  • Scan ran slither and semgrep against a single sandboxed copy of the source. Multi-file dependency analysis beyond what slither resolves automatically is out of scope.
  • Some detectors emitted warnings (see `warnings`); their output was still ingested but should be read with extra care.
  • This report is not a certification, audit attestation, or financial advice.

Exploit reasoning

No high-confidence exploit narratives

The analyzers did not produce findings at critical, high, or medium severity that map to a deterministic exploit narrative. This does not mean the contract is free of bugs; it means this scan path did not produce evidence strong enough to publish a narrative without operator review.

Audit pipeline

Audit cockpit

Honest stage-by-stage view of what VegaSec ran against this contract. Automated stages do not replace a human operator review.

Passed: 3Partial: 5Blocked: 1
  1. Audit intake

    Passed320ms replay12:36 AM

    Normalize the submitted contract target and confirm it can enter the Solidity audit lane.

    Next: Acquire verified source or scan the pasted Solidity source.

  2. Source acquisition

    Passed1.4s replay12:36 AM

    Resolve pasted source or verified explorer source without treating malformed input as demo data.

    Next: Validate the analyzer toolchain against the acquired source.

  3. Toolchain validation

    Partial2.3s replay12:36 AM

    Confirm the configured static analyzers can run and produce parseable output.

    Next: Run static analysis and capture raw detector evidence.

    • One or more analyzers emitted warnings; report findings remain usable but should be read with limitations.
  4. Static analysis

    Partial2 findings8.8s replay12:36 AM

    Run static analyzers against the sandboxed source and collect raw detector evidence.

    Next: Normalize detector output into one deduped finding set.

    • One or more analyzers emitted warnings; report findings remain usable but should be read with limitations.
  5. Finding normalization

    Passed2 findings1.1s replay12:36 AM

    Dedupe detectors, classify vulnerability classes and compute severity-weighted risk.

    Next: Review exploitability conservatively against confidence and limitations.

  6. Exploitability review

    Partial2 findings1.9s replay12:36 AM

    Frame automated findings with conservative exploitability and limitation notes.

    Next: Draft remediation notes from the normalized evidence.

    • Automated exploitability review is conservative and does not replace a manual exploitability assessment.
  7. Remediation draft

    Partial2 findings1.5s replay12:36 AM

    Prepare remediation-oriented evidence for the shareable report artifact.

    Next: Attach an operator review artifact before claiming human review.

    • Remediation notes are generated from detector evidence and require project-specific engineering review.
  8. Operator review

    Blocked0ms replay12:36 AM

    Record whether a human operator artifact exists before buyer escalation.

    Next: Attach a real operator review artifact before claiming human review.

    • No operator review artifact is attached to this automated scan.
    • Human operator review has not been attached to this automated scan yet.
  9. Finalization

    Partial2 findings620ms replay12:36 AM

    Publish the automated report artifact or explain why the scan failed closed.

    Next: Share the report with explicit limitations and review state.

    Artifact: Automated Solidity report · solidity-2f746d702f766567

    • Final report is an automated static-analysis artifact; no operator review artifact is attached.

Report badges

Verified sourceLow risk · automated

Badges describe the evidence carried by this report artifact, not financial value or future pricing. Operator-reviewed is never granted automatically.

How to read this report

Score, confidence, ranking: four moving parts, no hand-tuning.

Generated Oct 4, 2026, 12:36 AM · Solidity · FallbackOracle.sol

Score bands

  • 0-19

    AVOID-style triage

    Multiple high or critical findings, low source confidence, or unverified context. Public action should pause until a Private Review or a re-scan with better evidence.

  • 20-49

    High caution

    Notable findings or thin evidence. Worth a Private Review before relying on the artifact.

  • 50-69

    Watch

    Mixed signals: some evidence, some gaps. Re-scan after material changes to the target.

  • 70-89

    Clear surface (automated)

    No critical or high findings via static analysis. Not a safety claim: human review is still recommended for diligence work.

  • 90-100

    Strong surface (automated) · this report

    No critical or high findings, verified source, and high source confidence. Not a safety claim: human review is still recommended for diligence work.

Score
Deterministic 0-100 derived from severity counts. Same formula across every report. Lower means more risk.
Confidence
Separate axis. Measures how much VegaSec trusts the input data. Low confidence pushes the verdict toward UNKNOWN; the two are never collapsed into one number.
Ranking / percentile
Only meaningful within the eligible Trust Index set. Shown on /trust-index when the eligible pool is large enough. Today the public index is a controlled preview.

Private Review is separate

A paid Private Review does not raise the public score on this report. Public score reflects public-source evidence only. Private Review adds operator attestation and a confidential memo, never a score bump.

Export and share

  • · Shareable public URL: copy from the report actions panel.
  • · Markdown export: every export carries the report id, target, verdict, generated timestamp, and the public-data disclaimer.
  • · PDF export: not in this MVP. Tracked as a follow-up. The Markdown export contains the same content and prints cleanly to PDF from a browser today.

Source provenance

Verified source via Etherscan

View on Etherscan ↗
Chain
ETHEREUM
Address
0x9bc6…98b9
Contract name
FallbackOracle
Compiler
v0.8.9+commit.e5eed63a
License
MIT
EVM version
Default
Optimization
On · 200 runs
File count
1

Provenance is the public-explorer metadata captured at scan time. It is not a re-verification of compilation; the analyzer ran against the source string as returned by the explorer.

Scanned source (5,200 chars)

// Sources flattened with hardhat v2.10.1 https://hardhat.org

// File @openzeppelin/contracts/utils/Context.sol@v4.7.2

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


// File @openzeppelin/contracts/access/Ownable.sol@v4.7.2


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File contracts/interfaces/IPriceOracleGetter.sol


pragma solidity ^0.8.0;

interface IPriceOracleGetter {
  function getAssetPrice(address asset) external view returns (uint256);
}


// File contracts/interfaces/IPriceGetter.sol


pragma solidity ^0.8.0;

interface IPriceGetter {
  function getPrice() external view returns (uint256 price);
}


// File contracts/FallbackOracle.sol


pragma solidity ^0.8.0;



contract FallbackOracle is IPriceOracleGetter, Ownable {
  mapping (address => IPriceGetter) private assetToPriceGetter;

  constructor(address[] memory assets, address[] memory getters) {
    _setAssetPriceGetterBatch(assets, getters);
  }

  function getAssetPrice(address asset) external view returns (uint256) {
    require(address(assetToPriceGetter[asset]) != address(0), '!exists');
    return assetToPriceGetter[asset].getPrice();
  }

  function setAssetPriceGetter(address asset, address getter) external onlyOwner {
    assetToPriceGetter[asset] = IPriceGetter(getter);
  }

  function setAssetPriceGetterBatch(address[] calldata assets, address[] calldata getters) external onlyOwner {
    _setAssetPriceGetterBatch(assets, getters);
  }

  function _setAssetPriceGetterBatch(address[] memory assets, address[] memory getters) internal {
    require(assets.length == getters.length, '!equal');
    for (uint i = 0; i < assets.length; i++) {
      assetToPriceGetter[assets[i]] = IPriceGetter(getters[i]);
    }
  }
}

Public-data disclaimer

Solidity scans are triage based on slither + semgrep static analysis. Output is not a certification, audit attestation or financial advice. Findings can include false positives and may miss patterns the configured detectors do not cover.