CRE INTEGRATION

Since EIP-4844 (Dencun, March 2024), L1 basefee decoupled from L2 activity. Sequencer outages, bridge posting gaps and structural anomalies produce no economic signature on L1. Fee monitors are 100% blind to them. Every cross-chain agent operating today has no native observability of the substrate it executes on.

Every agentic system has an execution layer that orchestrates, calls and coordinates. No agentic system today has a layer that observes the structural state of the blockchain substrate it acts on.

Invarians classifies the blockchain infrastructure state across two independent axes: τ (structural rhythm) and π (demand pressure). Each combination maps to an execution context with distinct implications for autonomous agents.

Every call to Invarians returns a cryptographically signed snapshot of the current execution context: regime, freshness, and lineage. The agent applies its own policy. Invarians observes infrastructure state and signs it. Nothing more.

"chain":            "arbitrum",
"oracle_status":    "OK",
"l1_regime":        "S1D1",
"l2_regime":        "S1D2",
"bridge_state":     "BS1",
"l2_verified":      true,
"data_age_seconds": 312,
"signature":        "inv_sig_..."

Invarians is not built for one platform. Any system that executes autonomously on blockchain infrastructure gains observability by integrating the sensing layer.

The integration is a single HTTP call inserted between your trigger and your execution logic. Your workflow asks Invarians for the current regime: then decides based on that.

Drop this pattern into any existing CRE workflow. The sensing call adds one HTTP request per trigger fire: negligible overhead, complete infrastructure observability.

// ── my-workflow/main.ts ──────────────────────────────────────────────
import {
  CronCapability, HTTPClient, handler,
  consensusStringModeAggregation, Runner,
  type NodeRuntime, type Runtime
} from "@chainlink/cre-sdk"

// ── Config (from config.staging.json) ──────────────────────────────
type Config = {
  schedule:         string
  inVariansApiKey:  string   // your inv_* API key
  targetL1:         string   // "ethereum"
  targetL2:         string   // "arbitrum" | "base" | "optimism"
}

// ── Invarians response type ─────────────────────────────────────────
type InVariansContext = {
  oracle_status: "OK" | "STALE" | "OFFLINE"
  regime:        "S1D1" | "S1D2" | "S2D1" | "S2D2"
  l2_regime:     string
  bridge_state:  "BS1" | "BS2"
}

// ── Step 1: Fetch Invarians context (runs on every DON node) ────────
const fetchInVariansContext = (
  nodeRuntime: NodeRuntime<Config>
): InVariansContext => {
  const http = new HTTPClient()
  const l1 = nodeRuntime.config.targetL1
  const l2 = nodeRuntime.config.targetL2

  const resp = http.sendRequest(nodeRuntime, {
    url:    `https://sdpilypwumxsyyipceew.supabase.co/functions/v1/attestation/execution-context?from=${l1}&to=${l2}`,
    method: "GET" as const,
    headers: {
      "Authorization": `Bearer ${nodeRuntime.config.inVariansApiKey}`,
    }
  }).result()

  const data = JSON.parse(
    new TextDecoder().decode(resp.body)
  )
  const poc = data.proof_of_execution_context ?? {}

  return {
    oracle_status: data.oracle_status,
    regime:        poc.l1_regime    ?? "S1D1",
    l2_regime:     poc.l2_regime    ?? "N/A",
    bridge_state:  poc.bridge_state ?? "BS1",
  }
}

// ── Step 2: Main callback ────────────────────────────────────────────
const onTrigger = (runtime: Runtime<Config>): string => {

  // Query Invarians: BFT consensus across DON nodes on regime string
  const ctx = runtime.runInNodeMode(
    fetchInVariansContext,
    consensusStringModeAggregation()   // mode = most common value across nodes
  )().result()

  runtime.log(`Invarians: ${ctx.oracle_status}: L1:${ctx.regime} L2:${ctx.l2_regime} Bridge:${ctx.bridge_state}`)

  // ── Gate 1: Attestation freshness ────────────────────────────────
  if (ctx.oracle_status !== "OK") {
    runtime.log("Attestation STALE: deferring execution")
    return "deferred:oracle_stale"
  }

  // ── Gate 2: L1 structural stress ─────────────────────────────────
  if (ctx.regime === "S2D1" || ctx.regime === "S2D2") {
    runtime.log(`Structural stress detected (${ctx.regime}): deferring`)
    return `deferred:structural_stress:${ctx.regime}`
  }

  // ── Gate 3: Bridge state (cross-chain workflows) ──────────────────
  if (ctx.bridge_state === "BS2") {
    runtime.log("Bridge degraded: deferring cross-chain execution")
    return "deferred:bridge_degraded"
  }

  // ── Infrastructure nominal: proceed ──────────────────────────────
  runtime.log(`Nominal (${ctx.regime}): executing`)

  // ... your business logic here (onchain write, CCIP, computation)

  return `executed:${ctx.regime}`
}

// ── Workflow entry point ─────────────────────────────────────────────
const initWorkflow = (config: Config) => {
  const cron = new CronCapability()
  return [handler(cron.trigger({ schedule: config.schedule }), onTrigger)]
}

export async function main() {
  const runner = await Runner.newRunner<Config>()
  await runner.run(initWorkflow)
}

// config.staging.json
{
  "schedule":        "*/30 * * * * *",
  "inVariansApiKey": "inv_your_key_here",
  "targetL1":        "ethereum",
  "targetL2":        "arbitrum"
}

Each gate handles a distinct failure mode. None of these are visible to fee monitors or accessible without a dedicated sensing layer.