Bring certified infrastructure state
into smart contracts and AI agents

Chainlink Functions executes off-chain JavaScript on a decentralized oracle network and returns the result to your smart contract. The pattern below is designed to bring the Invarians execution context on-chain with a single Functions request.

// Invarians × Chainlink Functions, source.js
// Deploy via Chainlink Functions Toolkit, store API key as encrypted secret

const l1Chain = args[0] || "ethereum"    // L1 to read regime from
const l2Chain = args[1] || "arbitrum"    // L2 endpoint of the CCTP route
const apiKey  = secrets.INVARIANS_API_KEY

const response = await Functions.makeHttpRequest({
  url:     `https://api.invarians.com/v2/panel`,
  headers: { "Authorization": `Bearer ${apiKey}` },
  timeout: 5000
})

if (response.error) throw new Error(`API error: ${response.error}`)

const panel = response.data

// Guard: reject DEGRADED oracle
if (panel.oracle_status !== "OK") throw new Error(`Oracle ${panel.oracle_status}, not relaying`)

// Lookup L1 regime + CCTP route state
const l1Entry = panel.panel.l1.find(e => e.chain === l1Chain)
const bridge  = panel.panel.bridges.find(b => b.id === `${l2Chain}-${l1Chain}/cctp`)

if (!l1Entry || l1Entry.status !== "OK") throw new Error(`L1 ${l1Entry?.status ?? "missing"}`)
if (!bridge  || bridge.status  !== "OK") throw new Error(`Bridge ${bridge?.status ?? "missing"}`)

// Encode: panel.l1[].regime + panel.bridges[].state as packed string
// regime:       "S1D1" | "S1D2" | "S2D1" | "S2D2"
// bridge state: "BS1"  | "BS2"
return Functions.encodeString(l1Entry.regime + "|" + bridge.state)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@chainlink/contracts/src/v0.8/functions/FunctionsClient.sol";
import "@chainlink/contracts/src/v0.8/functions/ConfirmedOwner.sol";

contract InvariansGatedExecutor is FunctionsClient, ConfirmedOwner {

  // Last certified state from Invarians
  string public  lastL1Regime;        // "S1D1" | "S1D2" | "S2D1" | "S2D2"
  string public  lastBridgeState;     // "BS1" | "BS2"
  uint256 public lastUpdated;         // block.timestamp of last fulfilled request
  bytes32 public lastRequestId;

  event StateUpdated(string l1Regime, string bridgeState, uint256 timestamp);

  constructor(address router) FunctionsClient(router) ConfirmedOwner(msg.sender) {}

  // Modifier: gate execution on nominal L1 state
  modifier whenExecutable() {
    bytes32 s = keccak256(bytes(lastL1Regime));
    require(
      s == keccak256(bytes("S1D1")) || s == keccak256(bytes("S1D2")),
      "Invarians: panel.l1.regime not nominal"
    );
    require(block.timestamp - lastUpdated < 7200, "Invarians: state too old");
    _;
  }

  // Request a fresh state update from Invarians via Functions
  function requestStateUpdate(
    bytes32  donId,
    string memory source,      // source.js above, stored off-chain
    bytes memory  encryptedSecrets,
    string[] memory args,     // args[0] = chain name
    uint64   subscriptionId,
    uint32   gasLimit
  ) external onlyOwner returns (bytes32 requestId) {
    FunctionsRequest.Request memory req;
    req.initializeRequestForInlineJavaScript(source);
    req.addSecretsReference(encryptedSecrets);
    req.setArgs(args);
    lastRequestId = _sendRequest(req.encodeCBOR(), subscriptionId, gasLimit, donId);
    return lastRequestId;
  }

  // Callback from Chainlink Functions DON
  function fulfillRequest(bytes32 requestId, bytes memory response, bytes memory) internal override {
    if (requestId != lastRequestId) return;
    // Parse JSON response, use a JSON utility or decode off-chain then re-encode as ABI
    // Minimal pattern: store raw string, decode in UI layer
    string memory decoded = string(response);
    lastUpdated = block.timestamp;
    emit StateUpdated(lastL1Regime, lastBridgeState, lastUpdated);
  }

  // Example: gated execution function
  function executeWhenSafe() external whenExecutable {
    // Your execution logic here, only runs when panel.l1[].regime is S1D1 or S1D2
  }
}

CRE is Chainlink's orchestration layer for AI agents, agents that monitor conditions, make decisions, and execute on-chain actions without human intervention. Invarians provides the infrastructure sensing layer these agents are missing: what is the execution substrate doing right now?

# Invarians × CRE, agent sensing pattern (Python pseudocode)
# The agent queries Invarians before committing to any execution decision

import requests

INVARIANS_URL = "https://api.invarians.com"

def fetch_panel_state(api_key: str, l1_chain: str = "ethereum", l2_chain: str = "arbitrum"):
    headers = {"Authorization": f"Bearer {api_key}"}

    # Fetch full panel (L1 + L2 + bridges)
    panel = requests.get(f"{INVARIANS_URL}/panel", headers=headers).json()

    if panel.get("oracle_status") != "OK":
        return {"action": "defer", "reason": "oracle_degraded"}

    l1_entry = next((e for e in panel["panel"]["l1"] if e["chain"] == l1_chain), {})
    l2_entry = next((e for e in panel["panel"]["l2"] if e["chain"] == l2_chain), {})
    bridge   = next((b for b in panel["panel"]["bridges"]
                    if b["id"] == f"{l2_chain}-{l1_chain}/cctp"), {})

    sec = panel["signed_execution_context"]

    return {
        "l1":             l1_entry,             # { chain, regime, status, window }
        "l2":             l2_entry,             # { chain, regime, status, window }
        "bridge":         bridge,               # { id, state, calibrated, status, window }
        "signature":      sec["signature"],     # HMAC-SHA256, verifiable via /verify
        "payload_hash":   sec["payload_hash"],  # Canonical digest of the panel
        "audit_context":  panel                # Full signed panel, stored with each decision
    }

# Agent decision loop, agent applies its own policy on raw states
def agent_execution_loop():
    ctx = fetch_panel_state(api_key="inv_...")

    if ctx["l1"].get("regime", "").startswith("S1") and ctx["bridge"].get("state") == "BS1":
        execute_transaction()
        log_audit(ctx)                     # Certified context stored with each decision

    else:
        defer_execution(ctx)               # Structural stress or bridge degraded, do not execute
        log_audit(ctx)