Execution Context API

https://sdpilypwumxsyyipceew.supabase.co/functions/v1/attestation

import requests

API_KEY = "inv_your_api_key"
BASE_URL = "https://sdpilypwumxsyyipceew.supabase.co/functions/v1/attestation"

def get_state(chain: str) -> dict:
    r = requests.get(
        f"{BASE_URL}/{chain}",
        headers={"Authorization": f"Bearer {API_KEY}"}
    )
    r.raise_for_status()
    return r.json()

state = get_state("ethereum")
print(state["regime"])            # "S1D1" | "S1D2" | "S2D1" | "S2D2"
print(state["oracle_status"])     # "OK" | "STALE" | "OFFLINE"
print(state["data_age_seconds"])  # seconds since last data ingestion

const getState = async (chain) => {
  const res = await fetch(
    `https://sdpilypwumxsyyipceew.supabase.co/functions/v1/attestation/${chain}`,
    { headers: { Authorization: `Bearer ${API_KEY}` } }
  )
  return res.json()
}

const state = await getState("ethereum")
console.log(state.regime)          // "S1D1" | "S1D2" | "S2D1" | "S2D2"
console.log(state.oracle_status)   // "OK" | "STALE" | "OFFLINE"

Authorization: Bearer inv_your_api_key

{
  "chain":              "ethereum",
  "oracle_status":      "OK",          // "OK" | "STALE" | "OFFLINE"
  "regime":             "S1D2",        // S1D1 | S1D2 | S2D1 | S2D2
  "version":            "v2",

  "structural": {
    "rhythm_ratio":     1.002,         // normalized structural index
    "continuity_ratio": 1.000          // normalized structural index
  },

  "execution_profile": {
    "index_a":          1.225,         // normalized infrastructure metric
    "index_b":          1.083,         // normalized infrastructure metric
    "index_c":          1.051          // normalized infrastructure metric
  },

  "divergence_index":   -0.032,        // cross-layer divergence
  "data_age_seconds":   340,           // seconds since last ingestion: always check
  "l2_verified":        true,          // Ed25519 chain continuity verified

  "beacon": {           // ETH only
    "participation":    0.9987,
    "epoch":            318540,
    "age_seconds":      312
  },

  "issued_at":          "2026-03-03T10:00:00.000Z",
  "expires_at":         "2026-03-03T11:00:00.000Z",
  "signature":          "inv_sig_..."
}

{
  "oracle_status":  "OK",

  "proof_of_execution_context": {  // certified, signed
    "l1_regime":    "S1D2",          // S1D1 | S1D2 | S2D1 | S2D2
    "bridge_state": "BS1"            // BS1=nominal: BS2 integration Q2 2026
  },

  "l1": {
    "chain":            "ethereum",
    "regime":           "S1D2",
    "data_age_seconds": 1178
  },

  "l2": {
    "chain":              "arbitrum",
    "execution_profile": {
      "index_a": 1.000, "index_b": 1.002, "index_c": 1.008,
      "index_d": 1.023, "index_e": 1.041
    },
    "data_age_seconds":   2050
  },

  "data_age_seconds": 2050,
  "issued_at":        "2026-03-15T15:47:37Z",
  "signature":        "inv_sig_..."
}

def evaluate_state(chain: str) -> str:
    state = get_state(chain)

    # Always validate freshness first
    if state["oracle_status"] != "OK":
        return "DATA_UNAVAILABLE"
    if state.get("data_age_seconds", 9999) > 600:
        return "DATA_STALE"
    if not state.get("l2_verified", False):
        return "CHAIN_NOT_VERIFIED"

    return state["regime"]  # "S1D1" | "S1D2" | "S2D1" | "S2D2"

code = evaluate_state("ethereum")

if   code == "S1D1": handle_nominal()
elif code == "S1D2": handle_charge()
elif code == "S2D1": handle_anomaly()   # structural: invisible to fee monitors
elif code == "S2D2": handle_risk()
else:                  fallback()         # data unavailable / stale

ctx = get_execution_context("ethereum", "arbitrum")

if ctx["oracle_status"] != "OK":
    fallback()

proof     = ctx["proof_of_execution_context"]
l1_regime = proof["l1_regime"]    # S1D1 | S1D2 | S2D1 | S2D2
bridge    = proof["bridge_state"]  # BS1 | BS2

if l1_regime.startswith("S1") and bridge == "BS1":
    proceed()
else:
    defer_execution()

data          = get_state("ethereum")
oracle_status = data.get("oracle_status", "STALE")
data_age_s    = data.get("data_age_seconds", 9999)
regime        = data.get("regime", "UNKNOWN")

if oracle_status == "OK":
    apply_regime_policy(regime)

elif data_age_s <= 7200:
    log_warning(f"Signal stale ({data_age_s}s): using last known regime {regime}")
    apply_regime_policy(regime)  # at agent's discretion

else:
    log_warning(f"Signal stale ({data_age_s}s): deferring, state unknown")
    fallback()

data = get_state("ethereum")

verify = requests.post(
    "https://sdpilypwumxsyyipceew.supabase.co/functions/v1/attestation/verify",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "attestation": {k: v for k, v in data.items() if k != "signature"},
        "signature": data["signature"]
    }
)
print(verify.json())
# → { "valid": true, "expired": false }