s0racle-sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,2192 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PROGRAM_ID: () => PROGRAM_ID,
+  Region: () => Region,
+  clientDiversityIndex: () => clientDiversityIndex,
+  createS0racleClient: () => createS0racleClient,
+  dominantClient: () => dominantClient,
+  getNetworkHealthPDA: () => getNetworkHealthPDA,
+  getObserverPDA: () => getObserverPDA,
+  getRegistryPDA: () => getRegistryPDA,
+  healthStatus: () => healthStatus,
+  isConsensusCritical: () => isConsensusCritical,
+  isDegraded: () => isDegraded,
+  isObserverStale: () => isObserverStale,
+  isStale: () => isStale,
+  lamportsToSol: () => lamportsToSol,
+  latencyScore: () => latencyScore,
+  regionLabel: () => regionLabel,
+  stakeReachStatus: () => stakeReachStatus
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var import_web3 = require("@solana/web3.js");
+var Region = /* @__PURE__ */ ((Region2) => {
+  Region2["Asia"] = "Asia";
+  Region2["US"] = "US";
+  Region2["EU"] = "EU";
+  Region2["SouthAmerica"] = "SouthAmerica";
+  Region2["Africa"] = "Africa";
+  Region2["Oceania"] = "Oceania";
+  Region2["Other"] = "Other";
+  return Region2;
+})(Region || {});
+
+// src/accounts.ts
+var import_web32 = require("@solana/web3.js");
+var import_bn = require("bn.js");
+var PROGRAM_ID = new import_web32.PublicKey(
+  "2paXpX8Ze3tvYezviSwQJSSihG3LbrDiD7SNsaFwgTow"
+);
+var STALE_SLOTS = 150n;
+var SUPPORTED_REGISTRY_VERSION = 1;
+function getRegistryPDA(programId = PROGRAM_ID) {
+  return import_web32.PublicKey.findProgramAddressSync([Buffer.from("registry")], programId);
+}
+function getNetworkHealthPDA(programId = PROGRAM_ID) {
+  return import_web32.PublicKey.findProgramAddressSync(
+    [Buffer.from("network_health")],
+    programId
+  );
+}
+function getObserverPDA(observer, programId = PROGRAM_ID) {
+  return import_web32.PublicKey.findProgramAddressSync(
+    [Buffer.from("observer"), observer.toBuffer()],
+    programId
+  );
+}
+function toBigInt(val) {
+  if (typeof val === "bigint") return val;
+  if (typeof val === "number") return BigInt(val);
+  return BigInt(val.toString());
+}
+function toRegion(val) {
+  const key = typeof val === "string" ? val : Object.keys(val)[0] ?? "other";
+  const normalized = key.charAt(0).toUpperCase() + key.slice(1).toLowerCase();
+  const map = {
+    Asia: "Asia",
+    Us: "US",
+    Eu: "EU",
+    Southamerica: "SouthAmerica",
+    Africa: "Africa",
+    Oceania: "Oceania",
+    Other: "Other"
+  };
+  return map[normalized] ?? "Other";
+}
+function decodeAttestation(raw) {
+  return {
+    slot: toBigInt(raw["slot"]),
+    timestamp: toBigInt(raw["timestamp"]),
+    avgRttUs: raw["avgRttUs"],
+    p95RttUs: raw["p95RttUs"],
+    slotLatencyMs: raw["slotLatencyMs"],
+    tpuReachable: raw["tpuReachable"],
+    tpuProbed: raw["tpuProbed"],
+    agaveCount: raw["agaveCount"],
+    firedancerCount: raw["firedancerCount"],
+    jitoCount: raw["jitoCount"],
+    solanaLabsCount: raw["solanaLabsCount"],
+    otherCount: raw["otherCount"],
+    reachableStakePct: raw["reachableStakePct"]
+  };
+}
+function decodeRegionScore(raw) {
+  return {
+    region: toRegion(raw["region"]),
+    observerCount: raw["observerCount"],
+    healthScore: raw["healthScore"],
+    reachabilityPct: raw["reachabilityPct"],
+    avgRttUs: raw["avgRttUs"],
+    slotLatencyMs: raw["slotLatencyMs"],
+    lastUpdatedSlot: toBigInt(raw["lastUpdatedSlot"]),
+    agaveCount: raw["agaveCount"],
+    firedancerCount: raw["firedancerCount"],
+    jitoCount: raw["jitoCount"],
+    solanaLabsCount: raw["solanaLabsCount"],
+    otherCount: raw["otherCount"],
+    reachableStakePct: raw["reachableStakePct"]
+  };
+}
+function decodeNetworkHealth(raw) {
+  const minRaw = raw["minHealthEver"];
+  return {
+    healthScore: raw["healthScore"],
+    tpuReachabilityPct: raw["tpuReachabilityPct"],
+    avgSlotLatencyMs: raw["avgSlotLatencyMs"],
+    activeObserverCount: raw["activeObserverCount"],
+    activeRegionCount: raw["activeRegionCount"],
+    lastUpdatedSlot: toBigInt(raw["lastUpdatedSlot"]),
+    lastUpdatedTs: toBigInt(raw["lastUpdatedTs"]),
+    minHealthEver: minRaw === 255 ? null : minRaw,
+    maxHealthEver: raw["maxHealthEver"],
+    totalAttestations: toBigInt(raw["totalAttestations"]),
+    regionScores: raw["regionScores"].map(
+      decodeRegionScore
+    ),
+    agaveCount: raw["agaveCount"],
+    firedancerCount: raw["firedancerCount"],
+    jitoCount: raw["jitoCount"],
+    solanaLabsCount: raw["solanaLabsCount"],
+    otherCount: raw["otherCount"]
+  };
+}
+function decodeObserver(raw, publicKey) {
+  return {
+    publicKey,
+    authority: raw["authority"],
+    region: toRegion(raw["region"]),
+    stakeLamports: toBigInt(raw["stakeLamports"]),
+    registeredAt: toBigInt(raw["registeredAt"]),
+    lastAttestationSlot: toBigInt(raw["lastAttestationSlot"]),
+    attestationCount: toBigInt(raw["attestationCount"]),
+    latestAttestation: decodeAttestation(
+      raw["latestAttestation"]
+    ),
+    isActive: raw["isActive"]
+  };
+}
+function decodeRegistry(raw) {
+  const version = raw["version"];
+  if (version !== SUPPORTED_REGISTRY_VERSION) {
+    console.warn(
+      `s0racle-sdk: registry version ${version} is not supported by this SDK (expected ${SUPPORTED_REGISTRY_VERSION}). Upgrade s0racle-sdk to a compatible version.`
+    );
+  }
+  const pending = raw["pendingAuthority"];
+  return {
+    authority: raw["authority"],
+    pendingAuthority: pending ?? null,
+    minStakeLamports: toBigInt(raw["minStakeLamports"]),
+    observerCount: raw["observerCount"],
+    activeCount: raw["activeCount"],
+    maxObservers: raw["maxObservers"],
+    paused: raw["paused"],
+    version: raw["version"]
+  };
+}
+
+// src/client.ts
+var import_anchor2 = require("@coral-xyz/anchor");
+var import_web35 = require("@solana/web3.js");
+
+// src/idl/s0racle_program.json
+var s0racle_program_default = {
+  address: "2paXpX8Ze3tvYezviSwQJSSihG3LbrDiD7SNsaFwgTow",
+  metadata: {
+    name: "s0racle_program",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "Created with Anchor"
+  },
+  instructions: [
+    {
+      name: "accept_authority",
+      discriminator: [
+        107,
+        86,
+        198,
+        91,
+        33,
+        12,
+        107,
+        160
+      ],
+      accounts: [
+        {
+          name: "registry",
+          writable: true
+        },
+        {
+          name: "new_authority",
+          signer: true
+        }
+      ],
+      args: []
+    },
+    {
+      name: "crank_aggregation",
+      discriminator: [
+        37,
+        116,
+        43,
+        137,
+        4,
+        13,
+        88,
+        26
+      ],
+      accounts: [
+        {
+          name: "cranker",
+          signer: true
+        },
+        {
+          name: "network_health",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  110,
+                  101,
+                  116,
+                  119,
+                  111,
+                  114,
+                  107,
+                  95,
+                  104,
+                  101,
+                  97,
+                  108,
+                  116,
+                  104
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "registry_account",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "clock",
+          address: "SysvarC1ock11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "deregister_observer",
+      discriminator: [
+        16,
+        4,
+        225,
+        8,
+        113,
+        188,
+        135,
+        196
+      ],
+      accounts: [
+        {
+          name: "caller",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "observer_wallet",
+          docs: [
+            "Recipient of returned stake lamports on deregistration."
+          ],
+          writable: true
+        },
+        {
+          name: "observer_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  111,
+                  98,
+                  115,
+                  101,
+                  114,
+                  118,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "observer_wallet"
+              }
+            ]
+          }
+        },
+        {
+          name: "registry",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "initialize",
+      discriminator: [
+        175,
+        175,
+        109,
+        31,
+        13,
+        152,
+        155,
+        237
+      ],
+      accounts: [
+        {
+          name: "authority",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "registry",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "network_health",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  110,
+                  101,
+                  116,
+                  119,
+                  111,
+                  114,
+                  107,
+                  95,
+                  104,
+                  101,
+                  97,
+                  108,
+                  116,
+                  104
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "min_stake_lamports",
+          type: "u64"
+        },
+        {
+          name: "max_observers",
+          type: "u16"
+        }
+      ]
+    },
+    {
+      name: "propose_authority",
+      discriminator: [
+        20,
+        148,
+        236,
+        198,
+        76,
+        119,
+        99,
+        142
+      ],
+      accounts: [
+        {
+          name: "registry",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "registry"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "new_authority",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "register_observer",
+      discriminator: [
+        95,
+        238,
+        80,
+        77,
+        247,
+        96,
+        2,
+        225
+      ],
+      accounts: [
+        {
+          name: "observer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "observer_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  111,
+                  98,
+                  115,
+                  101,
+                  114,
+                  118,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "observer"
+              }
+            ]
+          }
+        },
+        {
+          name: "registry",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "region",
+          type: {
+            defined: {
+              name: "Region"
+            }
+          }
+        }
+      ]
+    },
+    {
+      name: "slash_observer",
+      discriminator: [
+        203,
+        50,
+        98,
+        246,
+        173,
+        53,
+        118,
+        177
+      ],
+      accounts: [
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "registry"
+          ]
+        },
+        {
+          name: "observer_wallet"
+        },
+        {
+          name: "observer_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  111,
+                  98,
+                  115,
+                  101,
+                  114,
+                  118,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "observer_wallet"
+              }
+            ]
+          }
+        },
+        {
+          name: "registry",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "treasury",
+          writable: true
+        }
+      ],
+      args: [
+        {
+          name: "slash_bps",
+          type: "u16"
+        }
+      ]
+    },
+    {
+      name: "submit_attestation",
+      discriminator: [
+        238,
+        220,
+        255,
+        105,
+        183,
+        211,
+        40,
+        83
+      ],
+      accounts: [
+        {
+          name: "authority",
+          writable: true,
+          signer: true,
+          relations: [
+            "observer_account"
+          ]
+        },
+        {
+          name: "observer_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  111,
+                  98,
+                  115,
+                  101,
+                  114,
+                  118,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "authority"
+              }
+            ]
+          }
+        },
+        {
+          name: "network_health",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  110,
+                  101,
+                  116,
+                  119,
+                  111,
+                  114,
+                  107,
+                  95,
+                  104,
+                  101,
+                  97,
+                  108,
+                  116,
+                  104
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "registry",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "clock",
+          address: "SysvarC1ock11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "tpu_reachable",
+          type: "u16"
+        },
+        {
+          name: "tpu_probed",
+          type: "u16"
+        },
+        {
+          name: "avg_rtt_us",
+          type: "u32"
+        },
+        {
+          name: "p95_rtt_us",
+          type: "u32"
+        },
+        {
+          name: "slot_latency_ms",
+          type: "u32"
+        },
+        {
+          name: "agave_count",
+          type: "u16"
+        },
+        {
+          name: "firedancer_count",
+          type: "u16"
+        },
+        {
+          name: "jito_count",
+          type: "u16"
+        },
+        {
+          name: "solana_labs_count",
+          type: "u16"
+        },
+        {
+          name: "other_count",
+          type: "u16"
+        },
+        {
+          name: "reachable_stake_pct",
+          type: "u8"
+        }
+      ]
+    },
+    {
+      name: "update_config",
+      discriminator: [
+        29,
+        158,
+        252,
+        191,
+        10,
+        83,
+        219,
+        99
+      ],
+      accounts: [
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "registry"
+          ]
+        },
+        {
+          name: "registry",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "min_stake_lamports",
+          type: {
+            option: "u64"
+          }
+        },
+        {
+          name: "max_observers",
+          type: {
+            option: "u16"
+          }
+        },
+        {
+          name: "paused",
+          type: {
+            option: "bool"
+          }
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "NetworkHealthAccount",
+      discriminator: [
+        90,
+        218,
+        55,
+        105,
+        239,
+        131,
+        43,
+        68
+      ]
+    },
+    {
+      name: "ObserverAccount",
+      discriminator: [
+        119,
+        24,
+        204,
+        152,
+        164,
+        169,
+        5,
+        101
+      ]
+    },
+    {
+      name: "RegistryAccount",
+      discriminator: [
+        113,
+        93,
+        106,
+        201,
+        100,
+        166,
+        146,
+        98
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "AttestationSubmitted",
+      discriminator: [
+        177,
+        213,
+        117,
+        225,
+        166,
+        11,
+        54,
+        218
+      ]
+    },
+    {
+      name: "ConfigUpdated",
+      discriminator: [
+        40,
+        241,
+        230,
+        122,
+        11,
+        19,
+        198,
+        194
+      ]
+    },
+    {
+      name: "ObserverDeregistered",
+      discriminator: [
+        78,
+        251,
+        104,
+        71,
+        5,
+        145,
+        253,
+        95
+      ]
+    },
+    {
+      name: "ObserverRegistered",
+      discriminator: [
+        33,
+        248,
+        190,
+        137,
+        191,
+        38,
+        49,
+        56
+      ]
+    },
+    {
+      name: "ObserverSlashed",
+      discriminator: [
+        132,
+        0,
+        84,
+        231,
+        39,
+        179,
+        32,
+        211
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "ValueCannotBeZero",
+      msg: "Value cannot be zero"
+    },
+    {
+      code: 6001,
+      name: "RegistryPaused",
+      msg: "Registry is currently paused"
+    },
+    {
+      code: 6002,
+      name: "MaxObserversReached",
+      msg: "Maximum number of observers has been reached"
+    },
+    {
+      code: 6003,
+      name: "InsufficientLamports",
+      msg: "Insufficient Lamports"
+    },
+    {
+      code: 6004,
+      name: "UnauthorizedObserver",
+      msg: "Unauthorized Observer"
+    },
+    {
+      code: 6005,
+      name: "ObserverNotActive",
+      msg: "Observer is not active"
+    },
+    {
+      code: 6006,
+      name: "ZeroValidatorsProbed",
+      msg: "Zero validators probed"
+    },
+    {
+      code: 6007,
+      name: "InsufficientValidatorsProbed",
+      msg: "Insufficient validators probed"
+    },
+    {
+      code: 6008,
+      name: "InvalidReachabilityCount",
+      msg: "Invalid reachability count"
+    },
+    {
+      code: 6009,
+      name: "InvalidLatencyValue",
+      msg: "Invalid latency submitted"
+    },
+    {
+      code: 6010,
+      name: "StaleAttestation",
+      msg: "Stale attestation"
+    },
+    {
+      code: 6011,
+      name: "NoActiveObservers",
+      msg: "No active observers"
+    },
+    {
+      code: 6012,
+      name: "ObserverAlreadyInActive",
+      msg: "Observer already inactive"
+    },
+    {
+      code: 6013,
+      name: "UnAuthorizedCaller",
+      msg: "Unauthorized caller"
+    },
+    {
+      code: 6014,
+      name: "InsufficientBalanceForRefund",
+      msg: "Insufficient balance in PDA for stake refund"
+    },
+    {
+      code: 6015,
+      name: "InvalidSlashBps",
+      msg: "Invalid slash basis points - must be <= 10000"
+    },
+    {
+      code: 6016,
+      name: "ObserverNotFound",
+      msg: "Observer not found"
+    },
+    {
+      code: 6017,
+      name: "InsufficientBalanceForSlash",
+      msg: "Insufficient balance in PDA for slash"
+    },
+    {
+      code: 6018,
+      name: "InvalidPendingAuthority",
+      msg: "Invalid or no pending authority for registry"
+    },
+    {
+      code: 6019,
+      name: "MaxObserversCannotBeLessThanActiveObservers",
+      msg: "Max observers cannot be less than active observers"
+    }
+  ],
+  types: [
+    {
+      name: "Attestation",
+      docs: [
+        "Single 10-second measurement from one observer node"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "slot",
+            docs: [
+              "Solana slot this measurement covers"
+            ],
+            type: "u64"
+          },
+          {
+            name: "timestamp",
+            docs: [
+              "Timestamp of the measurement"
+            ],
+            type: "i64"
+          },
+          {
+            name: "avg_rtt_us",
+            docs: [
+              "Average RTT of the QUIC probe"
+            ],
+            type: "u32"
+          },
+          {
+            name: "p95_rtt_us",
+            docs: [
+              "P95 RTT of the QUIC probe"
+            ],
+            type: "u32"
+          },
+          {
+            name: "slot_latency_ms",
+            docs: [
+              "Slot latency of the QUIC probe"
+            ],
+            type: "u32"
+          },
+          {
+            name: "tpu_reachable",
+            docs: [
+              "Validators reachable via QUIC probe"
+            ],
+            type: "u16"
+          },
+          {
+            name: "tpu_probed",
+            docs: [
+              "Total validators probed this round"
+            ],
+            type: "u16"
+          },
+          {
+            name: "agave_count",
+            docs: [
+              "Client distributions"
+            ],
+            type: "u16"
+          },
+          {
+            name: "firedancer_count",
+            type: "u16"
+          },
+          {
+            name: "jito_count",
+            type: "u16"
+          },
+          {
+            name: "solana_labs_count",
+            type: "u16"
+          },
+          {
+            name: "other_count",
+            type: "u16"
+          },
+          {
+            name: "reachable_stake_pct",
+            docs: [
+              "% of total stake (by lamports) reachable via QUIC probe"
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "AttestationSubmitted",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "observer",
+            type: "pubkey"
+          },
+          {
+            name: "region",
+            type: {
+              defined: {
+                name: "Region"
+              }
+            }
+          },
+          {
+            name: "score",
+            type: "u8"
+          },
+          {
+            name: "reachability_pct",
+            type: "u8"
+          },
+          {
+            name: "slot_latency_ms",
+            type: "u32"
+          },
+          {
+            name: "slot",
+            type: "u64"
+          },
+          {
+            name: "agave_count",
+            type: "u16"
+          },
+          {
+            name: "firedancer_count",
+            type: "u16"
+          },
+          {
+            name: "jito_count",
+            type: "u16"
+          },
+          {
+            name: "solana_labs_count",
+            type: "u16"
+          },
+          {
+            name: "other_count",
+            type: "u16"
+          },
+          {
+            name: "reachable_stake_pct",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "ConfigUpdated",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "min_stake_lamports",
+            type: {
+              option: "u64"
+            }
+          },
+          {
+            name: "max_observers",
+            type: {
+              option: "u16"
+            }
+          },
+          {
+            name: "paused",
+            type: {
+              option: "bool"
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "NetworkHealthAccount",
+      docs: [
+        "Global oracle account - the single source of truth for dApps and UI reads"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "health_score",
+            docs: [
+              "The health score of the network"
+            ],
+            type: "u8"
+          },
+          {
+            name: "tpu_reachability_pct",
+            docs: [
+              "TPU reachability % averaged across all regions"
+            ],
+            type: "u8"
+          },
+          {
+            name: "avg_slot_latency_ms",
+            docs: [
+              "Average slot latency in milliseconds"
+            ],
+            type: "u32"
+          },
+          {
+            name: "active_observer_count",
+            docs: [
+              "Number of active observers that contributed to this score"
+            ],
+            type: "u16"
+          },
+          {
+            name: "active_region_count",
+            docs: [
+              "Number of regions with fresh attestations"
+            ],
+            type: "u16"
+          },
+          {
+            name: "last_updated_slot",
+            docs: [
+              "Slot of last aggregation \u2014 dApps check this for staleness"
+            ],
+            type: "u64"
+          },
+          {
+            name: "last_updated_ts",
+            docs: [
+              "Unix timestamp of last update"
+            ],
+            type: "i64"
+          },
+          {
+            name: "min_health_ever",
+            docs: [
+              "Lowest health score ever recorded",
+              'Note: Initialized to 255 (u8::MAX) which represents "no data yet".'
+            ],
+            type: "u8"
+          },
+          {
+            name: "max_health_ever",
+            docs: [
+              "Highest health score ever recorded"
+            ],
+            type: "u8"
+          },
+          {
+            name: "total_attestations",
+            docs: [
+              "Total attestations ever submitted across all observers"
+            ],
+            type: "u64"
+          },
+          {
+            name: "region_scores",
+            docs: [
+              "One entry per region"
+            ],
+            type: {
+              array: [
+                {
+                  defined: {
+                    name: "RegionScore"
+                  }
+                },
+                7
+              ]
+            }
+          },
+          {
+            name: "agave_count",
+            type: "u8"
+          },
+          {
+            name: "firedancer_count",
+            type: "u8"
+          },
+          {
+            name: "jito_count",
+            type: "u8"
+          },
+          {
+            name: "solana_labs_count",
+            type: "u8"
+          },
+          {
+            name: "other_count",
+            type: "u8"
+          },
+          {
+            name: "bump",
+            docs: [
+              "PDA bump seed"
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "ObserverAccount",
+      docs: [
+        "Per-observer state - stores identity, region, stake and latest measurement"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            docs: [
+              "The authority of the observer"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "region",
+            docs: [
+              "The region of the observer"
+            ],
+            type: {
+              defined: {
+                name: "Region"
+              }
+            }
+          },
+          {
+            name: "stake_lamports",
+            docs: [
+              "The stake of the observer"
+            ],
+            type: "u64"
+          },
+          {
+            name: "registered_at",
+            docs: [
+              "The timestamp when the observer was registered"
+            ],
+            type: "i64"
+          },
+          {
+            name: "last_attestation_slot",
+            docs: [
+              "Solana slot of the most recent attestation submitted",
+              "Used for staleness check in crank_aggregation"
+            ],
+            type: "u64"
+          },
+          {
+            name: "attestation_count",
+            docs: [
+              "The number of attestations submitted by the observer"
+            ],
+            type: "u64"
+          },
+          {
+            name: "latest_attestation",
+            docs: [
+              "The latest attestation submitted by the observer"
+            ],
+            type: {
+              defined: {
+                name: "Attestation"
+              }
+            }
+          },
+          {
+            name: "is_active",
+            docs: [
+              "Whether the observer is active"
+            ],
+            type: "bool"
+          },
+          {
+            name: "bump",
+            docs: [
+              "The bump seed for the PDA"
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "ObserverDeregistered",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "observer",
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "ObserverRegistered",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "observer",
+            type: "pubkey"
+          },
+          {
+            name: "region",
+            type: {
+              defined: {
+                name: "Region"
+              }
+            }
+          },
+          {
+            name: "stake_lamports",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "ObserverSlashed",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "observer",
+            type: "pubkey"
+          },
+          {
+            name: "slash_bps",
+            type: "u16"
+          },
+          {
+            name: "amount_slashed",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "Region",
+      docs: [
+        "Geographic region of an observer node - serializes as u8 on-chain"
+      ],
+      type: {
+        kind: "enum",
+        variants: [
+          {
+            name: "Asia"
+          },
+          {
+            name: "US"
+          },
+          {
+            name: "EU"
+          },
+          {
+            name: "SouthAmerica"
+          },
+          {
+            name: "Africa"
+          },
+          {
+            name: "Oceania"
+          },
+          {
+            name: "Other"
+          }
+        ]
+      }
+    },
+    {
+      name: "RegionScore",
+      docs: [
+        "Health snapshot for one geographic region - embedded in NetworkHealthAccount"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "region",
+            docs: [
+              "Which region this entry represents"
+            ],
+            type: {
+              defined: {
+                name: "Region"
+              }
+            }
+          },
+          {
+            name: "observer_count",
+            docs: [
+              "Number of observer contributions currently represented in this region aggregate"
+            ],
+            type: "u16"
+          },
+          {
+            name: "health_score",
+            docs: [
+              "Health score from this region"
+            ],
+            type: "u8"
+          },
+          {
+            name: "reachability_pct",
+            docs: [
+              "TPU reachability % from this region"
+            ],
+            type: "u8"
+          },
+          {
+            name: "avg_rtt_us",
+            docs: [
+              "Average RTT from this region in microseconds"
+            ],
+            type: "u32"
+          },
+          {
+            name: "slot_latency_ms",
+            docs: [
+              "Slot propagation latency from this region (ms)"
+            ],
+            type: "u32"
+          },
+          {
+            name: "last_updated_slot",
+            docs: [
+              "Slot when this region last reported"
+            ],
+            type: "u64"
+          },
+          {
+            name: "total_health_score",
+            docs: [
+              "Running total of health scores for observers in this region"
+            ],
+            type: "u32"
+          },
+          {
+            name: "total_reachability_pct",
+            docs: [
+              "Running total of reachability percentages for observers in this region"
+            ],
+            type: "u32"
+          },
+          {
+            name: "total_avg_rtt_us",
+            docs: [
+              "Running total of RTT values for observers in this region"
+            ],
+            type: "u64"
+          },
+          {
+            name: "total_slot_latency_ms",
+            docs: [
+              "Running total of slot latency values for observers in this region"
+            ],
+            type: "u64"
+          },
+          {
+            name: "agave_count",
+            docs: [
+              "Client distribution counts for this region"
+            ],
+            type: "u16"
+          },
+          {
+            name: "firedancer_count",
+            type: "u16"
+          },
+          {
+            name: "jito_count",
+            type: "u16"
+          },
+          {
+            name: "solana_labs_count",
+            type: "u16"
+          },
+          {
+            name: "other_count",
+            type: "u16"
+          },
+          {
+            name: "total_agave_count",
+            docs: [
+              "Running totals"
+            ],
+            type: "u32"
+          },
+          {
+            name: "total_firedancer_count",
+            type: "u32"
+          },
+          {
+            name: "total_jito_count",
+            type: "u32"
+          },
+          {
+            name: "total_solana_labs_count",
+            type: "u32"
+          },
+          {
+            name: "total_other_count",
+            type: "u32"
+          },
+          {
+            name: "reachable_stake_pct",
+            docs: [
+              "Stake-weighted reachability for this region"
+            ],
+            type: "u8"
+          },
+          {
+            name: "total_reachable_stake_pct",
+            type: "u32"
+          }
+        ]
+      }
+    },
+    {
+      name: "RegistryAccount",
+      docs: [
+        "Global registry - tracks all observer nodes and program config"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            docs: [
+              "Admin key"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "pending_authority",
+            docs: [
+              "Pending authority for handoff"
+            ],
+            type: {
+              option: "pubkey"
+            }
+          },
+          {
+            name: "min_stake_lamports",
+            docs: [
+              "Minimum stake required to observe"
+            ],
+            type: "u64"
+          },
+          {
+            name: "observer_count",
+            docs: [
+              "Number of observers"
+            ],
+            type: "u16"
+          },
+          {
+            name: "active_count",
+            docs: [
+              "Currently active accounts"
+            ],
+            type: "u16"
+          },
+          {
+            name: "max_observers",
+            docs: [
+              "Maximum number of observers"
+            ],
+            type: "u16"
+          },
+          {
+            name: "paused",
+            docs: [
+              "Paused flag"
+            ],
+            type: "bool"
+          },
+          {
+            name: "version",
+            docs: [
+              "Version of the registry"
+            ],
+            type: "u8"
+          },
+          {
+            name: "bump",
+            docs: [
+              "Bump seed for the PDA"
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    }
+  ],
+  constants: [
+    {
+      name: "SEED",
+      type: "string",
+      value: '"anchor"'
+    }
+  ]
+};
+
+// src/instructions.ts
+var import_anchor = require("@coral-xyz/anchor");
+var import_bn2 = __toESM(require("bn.js"));
+var import_web33 = require("@solana/web3.js");
+var CLOCK_SYSVAR = new import_web33.PublicKey(
+  "SysvarC1ock11111111111111111111111111111111"
+);
+function toAnchorRegion(region) {
+  const map = {
+    ["Asia" /* Asia */]: "asia",
+    ["US" /* US */]: "us",
+    ["EU" /* EU */]: "eu",
+    ["SouthAmerica" /* SouthAmerica */]: "southAmerica",
+    ["Africa" /* Africa */]: "africa",
+    ["Oceania" /* Oceania */]: "oceania",
+    ["Other" /* Other */]: "other"
+  };
+  return { [map[region]]: {} };
+}
+async function buildRegisterObserver(program, observer, region) {
+  const programId = program.programId;
+  const [observerAccount] = getObserverPDA(observer, programId);
+  const [registry] = getRegistryPDA(programId);
+  return program.methods["registerObserver"](
+    toAnchorRegion(region)
+  ).accounts({ observer, observerAccount, registry }).instruction();
+}
+async function buildSubmitAttestation(program, authority, params) {
+  const programId = program.programId;
+  const [observerAccount] = getObserverPDA(authority, programId);
+  const [networkHealth] = getNetworkHealthPDA(programId);
+  const [registry] = getRegistryPDA(programId);
+  return program.methods["submitAttestation"](
+    params.tpuReachable,
+    params.tpuProbed,
+    params.avgRttUs,
+    params.p95RttUs,
+    params.slotLatencyMs,
+    params.agaveCount,
+    params.firedancerCount,
+    params.jitoCount,
+    params.solanaLabsCount,
+    params.otherCount,
+    params.reachableStakePct
+  ).accounts({
+    authority,
+    observerAccount,
+    networkHealth,
+    registry,
+    clock: CLOCK_SYSVAR
+  }).instruction();
+}
+async function buildDeregisterObserver(program, caller, observerWallet) {
+  const programId = program.programId;
+  const [observerAccount] = getObserverPDA(observerWallet, programId);
+  const [registry] = getRegistryPDA(programId);
+  return program.methods["deregisterObserver"]().accounts({ caller, observerWallet, observerAccount, registry }).instruction();
+}
+async function buildCrankAggregation(program, cranker, observerAccounts) {
+  const programId = program.programId;
+  const [networkHealth] = getNetworkHealthPDA(programId);
+  const [registryAccount] = getRegistryPDA(programId);
+  const remaining = observerAccounts.map((pubkey) => ({
+    pubkey,
+    isSigner: false,
+    isWritable: false
+  }));
+  return program.methods["crankAggregation"]().accounts({
+    cranker,
+    networkHealth,
+    registryAccount,
+    clock: CLOCK_SYSVAR
+  }).remainingAccounts(remaining).instruction();
+}
+async function buildInitialize(program, authority, minStakeLamports, maxObservers) {
+  const programId = program.programId;
+  const [registry] = getRegistryPDA(programId);
+  const [networkHealth] = getNetworkHealthPDA(programId);
+  return program.methods["initialize"](
+    new import_bn2.default(minStakeLamports.toString()),
+    maxObservers
+  ).accounts({ authority, registry, networkHealth }).instruction();
+}
+async function buildSlashObserver(program, authority, observerWallet, treasury, slashBps) {
+  const programId = program.programId;
+  const [observerAccount] = getObserverPDA(observerWallet, programId);
+  const [registry] = getRegistryPDA(programId);
+  return program.methods["slashObserver"](
+    slashBps
+  ).accounts({
+    authority,
+    observerWallet,
+    observerAccount,
+    registry,
+    treasury
+  }).instruction();
+}
+async function buildUpdateConfig(program, authority, params) {
+  const programId = program.programId;
+  const [registry] = getRegistryPDA(programId);
+  const minStake = params.minStakeLamports != null ? new import_bn2.default(params.minStakeLamports.toString()) : null;
+  return program.methods["updateConfig"](
+    minStake,
+    params.maxObservers,
+    params.paused
+  ).accounts({ authority, registry }).instruction();
+}
+async function buildProposeAuthority(program, authority, newAuthority) {
+  const programId = program.programId;
+  const [registry] = getRegistryPDA(programId);
+  return program.methods["proposeAuthority"](
+    newAuthority
+  ).accounts({ authority, registry }).instruction();
+}
+async function buildAcceptAuthority(program, newAuthority) {
+  const programId = program.programId;
+  const [registry] = getRegistryPDA(programId);
+  return program.methods["acceptAuthority"]().accounts({ newAuthority, registry }).instruction();
+}
+
+// src/events.ts
+var import_web34 = require("@solana/web3.js");
+var import_bn3 = require("bn.js");
+function toBigInt2(val) {
+  if (typeof val === "bigint") return val;
+  if (typeof val === "number") return BigInt(val);
+  return BigInt(val.toString());
+}
+function toRegion2(val) {
+  const key = typeof val === "string" ? val : Object.keys(val)[0] ?? "other";
+  const normalized = key.charAt(0).toUpperCase() + key.slice(1).toLowerCase();
+  const map = {
+    Asia: "Asia",
+    Us: "US",
+    Eu: "EU",
+    Southamerica: "SouthAmerica",
+    Africa: "Africa",
+    Oceania: "Oceania",
+    Other: "Other"
+  };
+  return map[normalized] ?? "Other";
+}
+function decodeAttestationSubmitted(raw) {
+  return {
+    observer: raw["observer"],
+    region: toRegion2(raw["region"]),
+    score: raw["score"],
+    reachabilityPct: raw["reachabilityPct"],
+    slotLatencyMs: raw["slotLatencyMs"],
+    slot: toBigInt2(raw["slot"]),
+    agaveCount: raw["agaveCount"],
+    firedancerCount: raw["firedancerCount"],
+    jitoCount: raw["jitoCount"],
+    solanaLabsCount: raw["solanaLabsCount"],
+    otherCount: raw["otherCount"],
+    reachableStakePct: raw["reachableStakePct"]
+  };
+}
+function decodeObserverRegistered(raw) {
+  return {
+    observer: raw["observer"],
+    region: toRegion2(raw["region"]),
+    stakeLamports: toBigInt2(raw["stakeLamports"])
+  };
+}
+function decodeObserverDeregistered(raw) {
+  return {
+    observer: raw["observer"]
+  };
+}
+function decodeObserverSlashed(raw) {
+  return {
+    observer: raw["observer"],
+    slashBps: raw["slashBps"],
+    amountSlashed: toBigInt2(raw["amountSlashed"])
+  };
+}
+function decodeConfigUpdated(raw) {
+  const minStake = raw["minStakeLamports"];
+  const maxObs = raw["maxObservers"];
+  const paused = raw["paused"];
+  return {
+    minStakeLamports: minStake != null ? toBigInt2(minStake) : null,
+    maxObservers: maxObs != null ? maxObs : null,
+    paused: paused != null ? paused : null
+  };
+}
+
+// src/client.ts
+var READ_ONLY_PUBKEY = new import_web35.PublicKey("11111111111111111111111111111111");
+function createReadOnlyWallet() {
+  return {
+    publicKey: READ_ONLY_PUBKEY,
+    payer: import_web35.Keypair.generate(),
+    signTransaction: async (tx) => tx,
+    signAllTransactions: async (txs) => txs
+  };
+}
+function createS0racleClient(opts) {
+  const { connection } = opts;
+  const programId = opts.programId ?? PROGRAM_ID;
+  const wallet = opts.wallet ?? createReadOnlyWallet();
+  const provider = new import_anchor2.AnchorProvider(connection, wallet, {
+    commitment: "confirmed"
+  });
+  const idl = { ...s0racle_program_default, address: programId.toBase58() };
+  const program = new import_anchor2.Program(idl, provider);
+  async function getNetworkHealth() {
+    const [pda] = getNetworkHealthPDA(programId);
+    const raw = await program.account["networkHealthAccount"].fetch(pda);
+    return decodeNetworkHealth(raw);
+  }
+  async function getRegistry() {
+    const [pda] = getRegistryPDA(programId);
+    const raw = await program.account["registryAccount"].fetch(pda);
+    return decodeRegistry(raw);
+  }
+  async function getObserver(observerPubkey) {
+    const [pda] = getObserverPDA(observerPubkey, programId);
+    const raw = await program.account["observerAccount"].fetch(pda);
+    return decodeObserver(raw, pda);
+  }
+  async function getAllObservers() {
+    const all = await program.account["observerAccount"].all();
+    return all.map(
+      (entry) => decodeObserver(entry.account, entry.publicKey)
+    );
+  }
+  async function getObserversByRegion(region) {
+    const all = await getAllObservers();
+    return all.filter((o) => o.region === region);
+  }
+  return {
+    programId,
+    connection,
+    // Reads
+    getNetworkHealth,
+    getRegistry,
+    getObserver,
+    getAllObservers,
+    getObserversByRegion,
+    // Instruction builders
+    registerObserver: (observer, region) => buildRegisterObserver(program, observer, region),
+    submitAttestation: (authority, params) => buildSubmitAttestation(program, authority, params),
+    deregisterObserver: (caller, observerWallet) => buildDeregisterObserver(program, caller, observerWallet),
+    crankAggregation: (cranker, observerAccounts) => buildCrankAggregation(program, cranker, observerAccounts),
+    initialize: (authority, minStakeLamports, maxObservers) => buildInitialize(program, authority, minStakeLamports, maxObservers),
+    slashObserver: (authority, observerWallet, treasury, slashBps) => buildSlashObserver(
+      program,
+      authority,
+      observerWallet,
+      treasury,
+      slashBps
+    ),
+    updateConfig: (authority, params) => buildUpdateConfig(program, authority, params),
+    proposeAuthority: (authority, newAuthority) => buildProposeAuthority(program, authority, newAuthority),
+    acceptAuthority: (newAuthority) => buildAcceptAuthority(program, newAuthority),
+    // Event subscriptions
+    onAttestationSubmitted: (callback) => program.addEventListener(
+      "attestationSubmitted",
+      (raw, slot) => callback(
+        decodeAttestationSubmitted(raw),
+        slot
+      )
+    ),
+    onObserverRegistered: (callback) => program.addEventListener(
+      "observerRegistered",
+      (raw, slot) => callback(
+        decodeObserverRegistered(raw),
+        slot
+      )
+    ),
+    onObserverDeregistered: (callback) => program.addEventListener(
+      "observerDeregistered",
+      (raw, slot) => callback(
+        decodeObserverDeregistered(raw),
+        slot
+      )
+    ),
+    onObserverSlashed: (callback) => program.addEventListener(
+      "observerSlashed",
+      (raw, slot) => callback(decodeObserverSlashed(raw), slot)
+    ),
+    onConfigUpdated: (callback) => program.addEventListener(
+      "configUpdated",
+      (raw, slot) => callback(decodeConfigUpdated(raw), slot)
+    ),
+    removeEventListener: (listenerId) => program.removeEventListener(listenerId)
+  };
+}
+
+// src/utils.ts
+var DEFAULT_DEGRADED_THRESHOLD = 70;
+var DEFAULT_CRITICAL_THRESHOLD = 40;
+function isStale(networkHealth, currentSlot) {
+  return currentSlot - networkHealth.lastUpdatedSlot > STALE_SLOTS;
+}
+function isObserverStale(observer, currentSlot) {
+  return currentSlot - observer.lastAttestationSlot > STALE_SLOTS;
+}
+function isDegraded(networkHealth, threshold = DEFAULT_DEGRADED_THRESHOLD) {
+  return networkHealth.healthScore < threshold;
+}
+function healthStatus(networkHealth, currentSlot) {
+  if (currentSlot !== void 0 && isStale(networkHealth, currentSlot)) {
+    return "stale";
+  }
+  if (networkHealth.healthScore < DEFAULT_CRITICAL_THRESHOLD) return "critical";
+  if (networkHealth.healthScore < DEFAULT_DEGRADED_THRESHOLD) return "degraded";
+  return "healthy";
+}
+function regionLabel(region) {
+  switch (region) {
+    case "Asia" /* Asia */:
+      return "Asia";
+    case "US" /* US */:
+      return "United States";
+    case "EU" /* EU */:
+      return "Europe";
+    case "SouthAmerica" /* SouthAmerica */:
+      return "South America";
+    case "Africa" /* Africa */:
+      return "Africa";
+    case "Oceania" /* Oceania */:
+      return "Oceania";
+    case "Other" /* Other */:
+      return "Other";
+  }
+}
+function lamportsToSol(lamports) {
+  return Number(lamports) / 1e9;
+}
+function latencyScore(slotLatencyMs) {
+  if (slotLatencyMs >= 400) return 0;
+  return Math.floor((400 - slotLatencyMs) * 100 / 400);
+}
+function isConsensusCritical(reachableStakePct) {
+  return reachableStakePct < 67;
+}
+function stakeReachStatus(reachableStakePct) {
+  if (reachableStakePct >= 80) return "healthy";
+  if (reachableStakePct >= 67) return "degraded";
+  return "critical";
+}
+function dominantClient(region) {
+  const counts = {
+    agave: region.agaveCount,
+    firedancer: region.firedancerCount,
+    jito: region.jitoCount,
+    other: region.otherCount + region.solanaLabsCount
+  };
+  return Object.entries(counts).sort((a, b) => b[1] - a[1])[0][0];
+}
+function clientDiversityIndex(region) {
+  const total = region.agaveCount + region.firedancerCount + region.jitoCount + region.solanaLabsCount + region.otherCount;
+  if (total === 0) return 0;
+  const shares = [
+    region.agaveCount,
+    region.firedancerCount,
+    region.jitoCount,
+    region.solanaLabsCount,
+    region.otherCount
+  ].map((c) => c / total);
+  const hhi = shares.reduce((sum, s) => sum + s * s, 0);
+  return Math.round((1 - hhi) * 125);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROGRAM_ID,
+  Region,
+  clientDiversityIndex,
+  createS0racleClient,
+  dominantClient,
+  getNetworkHealthPDA,
+  getObserverPDA,
+  getRegistryPDA,
+  healthStatus,
+  isConsensusCritical,
+  isDegraded,
+  isObserverStale,
+  isStale,
+  lamportsToSol,
+  latencyScore,
+  regionLabel,
+  stakeReachStatus
+});
+//# sourceMappingURL=index.js.map