> ## Documentation Index
> Fetch the complete documentation index at: https://phylaxsystems-docs-project-incidents.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Network Integration Overview

> High-level integration path for networks and sequencers adopting the Credible Layer

This page explains how networks integrate the Credible Layer at a high level. It focuses on the
interface surfaces and operational expectations without internal implementation details.

## Who This Is For

* L2 networks and sequencers evaluating integration
* Infrastructure teams operating block builders or validators
* Security teams defining network-level enforcement goals

## High-Level Flow

```mermaid theme={null}
---
title: Network Integration Flow
---
flowchart LR
  Users[Users + dApps] --> RPC[Network RPC]
  RPC --> Builder[Block Builder]
  Builder --> Enforcer[Assertion Enforcer]
  Enforcer -->|valid| Block[Block]
  Enforcer -->|invalid| Drop[Dropped]
  Enforcer -.-> Registry[On-Chain Registry]
  Enforcer -.-> DA[Assertion DA]
```

## Integration Surfaces

Networks provide the following integration surfaces:

* **Block-building hook**: the block builder queries the Assertion Enforcer before including a
  transaction
* **Registry access**: the enforcer consumes registry data (indexed from on-chain events) to discover which assertions apply
* **Assertion data access**: the enforcer fetches assertion bytecode from Assertion DA
* **Operational monitoring**: incidents and status are surfaced via the Credible dApp

## Operational Expectations

* The enforcer runs alongside the block builder and does not change consensus rules
* Enforcement is deterministic and only depends on on-chain state and assertion code
* dApps choose whether assertions are staged or enforced; networks honor the registry status during validation

## Integration Checklist (High Level)

* Identify the block-building hook for transaction validation
* Configure access to registry data and assertion bytecode
* Ensure the enforcer respects staged vs enforced assertions as set by dApps
* Set up monitoring and incident review workflows

## Integration Requirements (Public)

* **Block-building hook** that can query the enforcer before inclusion
* **Registry access** for assertion discovery (on-chain events indexed locally)
* **DA access** for assertion bytecode retrieval
* **Incident visibility** through the Credible dApp

## Next Steps

<CardGroup cols={2}>
  <Card title="Architecture Overview" icon="diagram-project" href="/credible/architecture-overview">
    Detailed system architecture and transaction flow
  </Card>

  <Card title="Linea / Besu Integration" icon="plug" href="/credible/network-integrations/architecture-linea">
    Plugin-based integration pattern for Besu
  </Card>

  <Card title="Assertion Enforcer" icon="shield" href="/credible/assertion-enforcer">
    Sidecar validation flow and enforcement role
  </Card>

  <Card title="OP Stack Implementation" icon="sitemap" href="/credible/network-integrations/architecture-op-stack">
    OP Stack integration notes
  </Card>
</CardGroup>