x402-trust-layer 5.1.0

package/dist/protocol/pipeline-full-trust.js

@@ -0,0 +1,96 @@
+import { config } from "../config.js";
+import { runPreX402Guard } from "../agents/pre-x402-guard.js";
+import { issueAgentPassport } from "./agent-passport.js";
+import { computeTrustScoreV2 } from "./trust-score-v2.js";
+import { runFraudScan } from "./fraud-engine.js";
+import { runTrustOracleConsensus } from "./trust-oracle.js";
+import { createReplayBinding } from "./replay-guard.js";
+import { computeAgentCreditScore } from "./credit-bureau.js";
+import { assessCompliance } from "./compliance-v2.js";
+import { recordProtocolMetric } from "./observability.js";
+export async function runFullTrustPipeline(input) {
+    await recordProtocolMetric("pipeline.full_trust.start", { agentId: input.agentId });
+    const passport = await issueAgentPassport({
+        agentId: input.agentId,
+        walletAddress: input.walletAddress,
+    });
+    const trustV2 = await computeTrustScoreV2({
+        agentId: input.agentId,
+        walletAddress: input.walletAddress,
+    });
+    const fraud = await runFraudScan({
+        agentId: input.agentId,
+        walletAddress: input.walletAddress,
+        merchantHost: new URL(input.targetUrl).hostname,
+        amountUsdc: input.estimatedCostUsdc,
+    });
+    const oracle = await runTrustOracleConsensus({
+        subjectType: "agent",
+        subjectId: input.agentId,
+        claims: { trustScore: trustV2.trustScore, fraudScore: fraud.fraudScore },
+    });
+    const credit = await computeAgentCreditScore({
+        agentId: input.agentId,
+        walletAddress: input.walletAddress,
+    });
+    const compliance = assessCompliance({
+        organizationId: input.organizationId ?? "default-org",
+        agentId: input.agentId,
+        monthlyVolumeUsdc: input.estimatedCostUsdc * 30,
+    });
+    const replayBinding = await createReplayBinding({
+        agentId: input.agentId,
+        resourceUrl: input.targetUrl,
+        requestBody: { estimatedCostUsdc: input.estimatedCostUsdc },
+    });
+    const guard = await runPreX402Guard({
+        agentId: input.agentId,
+        walletAddress: input.walletAddress,
+        targetUrl: input.targetUrl,
+        estimatedCostUsdc: input.estimatedCostUsdc,
+        policy: input.policy,
+        minTrustScore: 50,
+    });
+    const allowed = guard.allowed &&
+        fraud.fraudScore < 60 &&
+        oracle.consensus &&
+        compliance.allowed &&
+        credit.creditScore >= 500;
+    await recordProtocolMetric("pipeline.full_trust.complete", {
+        agentId: input.agentId,
+        allowed: String(allowed),
+    });
+    return {
+        status: "ok",
+        allowed,
+        summary: allowed
+            ? "Full trust pipeline passed — safe to proceed with x402 payment"
+            : "Full trust pipeline blocked — review fraud, oracle, compliance, or guard",
+        passport: { did: passport.did, riskTier: passport.riskTier },
+        trustV2,
+        fraud,
+        oracle,
+        credit,
+        compliance,
+        replayBinding: {
+            bindingId: replayBinding.bindingId,
+            header: "X-Trust-Replay-Binding",
+            nonce: replayBinding.nonce,
+            expiresAt: replayBinding.expiresAt,
+        },
+        guard: {
+            allowed: guard.allowed,
+            securityGrade: guard.securityGrade,
+            summary: guard.summary,
+        },
+        nextSteps: allowed
+            ? [
+                `Attach header X-Trust-Replay-Binding: ${replayBinding.bindingId}`,
+                "Pay target with x402_fetch / OpenDexter",
+                "POST /api/protocol/execution/issue with tool trace + settlement",
+            ]
+            : ["Review blockers", "POST /api/protocol/fraud/scan for detail"],
+        protocolVersion: "4.0.0",
+        docs: `${config.publicBaseUrl}/api/protocol/architecture`,
+    };
+}

package/dist/protocol/proof-of-execution.d.ts

@@ -0,0 +1,36 @@
+export type ExecutionReceiptInput = {
+    agentId: string;
+    taskId?: string;
+    targetUrl?: string;
+    toolTrace?: Array<{
+        name: string;
+        url?: string;
+        amountUsdc?: number;
+    }>;
+    decisionTrace?: string[];
+    settlement?: {
+        transactionHash?: string;
+        network?: string;
+        amountUsdc?: number;
+    };
+    responseSummary?: string;
+};
+export type ExecutionReceipt = {
+    receiptId: string;
+    taskId: string;
+    executionHash: string;
+    toolTraceHash: string;
+    decisionTraceHash: string;
+    verificationProof: string;
+    settlementProof: string | null;
+    issuedAt: string;
+    thirdPartyVerifyUrl: string;
+};
+export declare function issueExecutionReceipt(input: ExecutionReceiptInput, publicBaseUrl: string): Promise<ExecutionReceipt & {
+    signature: string;
+}>;
+export declare function verifyExecutionReceipt(receiptId: string): Promise<{
+    valid: boolean;
+    receipt: ExecutionReceipt | null;
+    reason?: string;
+}>;

package/dist/protocol/proof-of-execution.js

@@ -0,0 +1,48 @@
+import { hmacSign, sha256Hex } from "./crypto.js";
+import { readProtocolStore, writeProtocolStore } from "./store.js";
+export async function issueExecutionReceipt(input, publicBaseUrl) {
+    const store = await readProtocolStore("execution-receipts", {});
+    const taskId = input.taskId ?? `task_${Date.now().toString(36)}`;
+    const toolTraceJson = JSON.stringify(input.toolTrace ?? []);
+    const decisionJson = JSON.stringify(input.decisionTrace ?? []);
+    const executionHash = sha256Hex(`${input.agentId}:${taskId}:${input.targetUrl ?? ""}:${input.responseSummary ?? ""}`);
+    const toolTraceHash = sha256Hex(toolTraceJson);
+    const decisionTraceHash = sha256Hex(decisionJson);
+    const settlementProof = input.settlement?.transactionHash
+        ? sha256Hex(JSON.stringify(input.settlement))
+        : null;
+    const receiptId = `poe_${sha256Hex(executionHash).slice(0, 16)}`;
+    const verificationProof = hmacSign(`${receiptId}:${executionHash}:${toolTraceHash}:${decisionTraceHash}`);
+    const receipt = {
+        receiptId,
+        taskId,
+        executionHash,
+        toolTraceHash,
+        decisionTraceHash,
+        verificationProof,
+        settlementProof,
+        issuedAt: new Date().toISOString(),
+        thirdPartyVerifyUrl: `${publicBaseUrl}/api/protocol/execution/verify`,
+    };
+    const payload = JSON.stringify(receipt);
+    const signature = hmacSign(payload);
+    store[receiptId] = { ...receipt, signature, payload };
+    await writeProtocolStore("execution-receipts", store);
+    return { ...receipt, signature };
+}
+export async function verifyExecutionReceipt(receiptId) {
+    const store = await readProtocolStore("execution-receipts", {});
+    const row = store[receiptId];
+    if (!row)
+        return { valid: false, receipt: null, reason: "Receipt not found" };
+    const { signature, payload, ...receipt } = row;
+    const expected = hmacSign(payload);
+    if (expected !== signature) {
+        return { valid: false, receipt, reason: "Receipt signature invalid" };
+    }
+    const recomputed = hmacSign(`${receipt.receiptId}:${receipt.executionHash}:${receipt.toolTraceHash}:${receipt.decisionTraceHash}`);
+    if (recomputed !== receipt.verificationProof) {
+        return { valid: false, receipt, reason: "Verification proof mismatch" };
+    }
+    return { valid: true, receipt };
+}

package/dist/protocol/reasoning-audit.d.ts

@@ -0,0 +1,27 @@
+export type ReasoningCommitInput = {
+    agentId: string;
+    sessionId?: string;
+    toolCalls: Array<{
+        name: string;
+        argsHash?: string;
+    }>;
+    policyChecks: string[];
+    promptHashes: string[];
+    riskAnalysis?: string;
+    decisionGraph?: Record<string, unknown>;
+};
+export type ReasoningCommitResult = {
+    auditId: string;
+    merkleRoot: string;
+    leafCount: number;
+    committedAt: string;
+    zkReady: boolean;
+    disclosureHint: string;
+};
+export declare function commitReasoningAudit(input: ReasoningCommitInput): Promise<ReasoningCommitResult>;
+export declare function selectiveDisclose(auditId: string, leafIndices: number[]): Promise<{
+    ok: boolean;
+    disclosed: string[];
+    merkleProof: string[];
+    reason?: string;
+}>;

package/dist/protocol/reasoning-audit.js

@@ -0,0 +1,51 @@
+import { merkleRoot, sha256Hex, hmacSign } from "./crypto.js";
+import { readProtocolStore, writeProtocolStore } from "./store.js";
+export async function commitReasoningAudit(input) {
+    const leaves = [];
+    for (const t of input.toolCalls) {
+        leaves.push(sha256Hex(`tool:${t.name}:${t.argsHash ?? ""}`));
+    }
+    for (const p of input.promptHashes) {
+        leaves.push(sha256Hex(`prompt:${p}`));
+    }
+    for (const c of input.policyChecks) {
+        leaves.push(sha256Hex(`policy:${c}`));
+    }
+    if (input.riskAnalysis)
+        leaves.push(sha256Hex(`risk:${input.riskAnalysis}`));
+    if (input.decisionGraph)
+        leaves.push(sha256Hex(`graph:${JSON.stringify(input.decisionGraph)}`));
+    const root = merkleRoot(leaves);
+    const auditId = `aud_${sha256Hex(root).slice(0, 16)}`;
+    const store = await readProtocolStore("reasoning-audits", {});
+    store[auditId] = {
+        merkleRoot: root,
+        leaves,
+        agentId: input.agentId,
+        committedAt: new Date().toISOString(),
+        signature: hmacSign(`${auditId}:${root}`),
+    };
+    await writeProtocolStore("reasoning-audits", store);
+    return {
+        auditId,
+        merkleRoot: root,
+        leafCount: leaves.length,
+        committedAt: store[auditId].committedAt,
+        zkReady: true,
+        disclosureHint: "Use POST /api/protocol/reasoning/disclose with leaf indices for selective reveal",
+    };
+}
+export async function selectiveDisclose(auditId, leafIndices) {
+    const store = await readProtocolStore("reasoning-audits", {});
+    const row = store[auditId];
+    if (!row)
+        return { ok: false, disclosed: [], merkleProof: [], reason: "Audit not found" };
+    const disclosed = leafIndices
+        .filter((i) => i >= 0 && i < row.leaves.length)
+        .map((i) => row.leaves[i]);
+    return {
+        ok: true,
+        disclosed,
+        merkleProof: [row.merkleRoot, ...disclosed],
+    };
+}

package/dist/protocol/replay-guard.d.ts

@@ -0,0 +1,28 @@
+export type ReplayBindingInput = {
+    agentId: string;
+    sessionId?: string;
+    resourceUrl: string;
+    method?: string;
+    requestBody?: unknown;
+    ttlSeconds?: number;
+};
+export type ReplayBinding = {
+    bindingId: string;
+    nonce: string;
+    resourceHash: string;
+    requestHash: string;
+    agentId: string;
+    sessionId: string;
+    expiresAt: string;
+    signature: string;
+};
+export declare function createReplayBinding(input: ReplayBindingInput): Promise<ReplayBinding>;
+export declare function verifyReplayBinding(bindingId: string, headers: {
+    nonce?: string;
+    resourceUrl?: string;
+    requestBody?: unknown;
+    agentId?: string;
+}): Promise<{
+    valid: boolean;
+    reason?: string;
+}>;

package/dist/protocol/replay-guard.js

@@ -0,0 +1,76 @@
+import { sha256Hex, hmacSign, verifyHmac } from "./crypto.js";
+import { claimNonceKey, isNonceKeyUsed } from "../lib/nonce-store.js";
+import { readProtocolStore, writeProtocolStore } from "./store.js";
+async function claimNonceOnce(nonce) {
+    const safe = nonce.replace(/[^a-f0-9]/gi, "").slice(0, 64);
+    if (!safe)
+        return false;
+    const key = `proto:${safe}`;
+    if (isNonceKeyUsed(key))
+        return false;
+    return claimNonceKey(key, "protocol-replay");
+}
+export async function createReplayBinding(input) {
+    const nonce = sha256Hex(`${Date.now()}:${input.agentId}`).slice(0, 32);
+    const resourceHash = sha256Hex(`${input.method ?? "POST"}:${input.resourceUrl}`);
+    const requestHash = sha256Hex(JSON.stringify(input.requestBody ?? {}));
+    const sessionId = input.sessionId ?? `sess_${input.agentId}`;
+    const ttl = input.ttlSeconds ?? 300;
+    const expiresAt = new Date(Date.now() + ttl * 1000).toISOString();
+    const bindingId = `rb_${nonce.slice(0, 16)}`;
+    const payload = {
+        bindingId,
+        nonce,
+        resourceHash,
+        requestHash,
+        agentId: input.agentId,
+        sessionId,
+        expiresAt,
+    };
+    const signature = hmacSign(JSON.stringify(payload));
+    const binding = { ...payload, signature };
+    const store = await readProtocolStore("replay-bindings", {});
+    store[bindingId] = binding;
+    await writeProtocolStore("replay-bindings", store);
+    return binding;
+}
+export async function verifyReplayBinding(bindingId, headers) {
+    const store = await readProtocolStore("replay-bindings", {});
+    const binding = store[bindingId];
+    if (!binding)
+        return { valid: false, reason: "Binding not found" };
+    const payload = JSON.stringify({
+        bindingId: binding.bindingId,
+        nonce: binding.nonce,
+        resourceHash: binding.resourceHash,
+        requestHash: binding.requestHash,
+        agentId: binding.agentId,
+        sessionId: binding.sessionId,
+        expiresAt: binding.expiresAt,
+    });
+    if (!verifyHmac(payload, binding.signature)) {
+        return { valid: false, reason: "Binding signature invalid" };
+    }
+    if (new Date(binding.expiresAt).getTime() < Date.now()) {
+        return { valid: false, reason: "Binding expired" };
+    }
+    if (headers.nonce && headers.nonce !== binding.nonce) {
+        return { valid: false, reason: "Nonce mismatch" };
+    }
+    if (headers.resourceUrl) {
+        const rh = sha256Hex(`POST:${headers.resourceUrl}`);
+        if (rh !== binding.resourceHash) {
+            return { valid: false, reason: "Resource substitution detected" };
+        }
+    }
+    if (headers.requestBody !== undefined) {
+        const rq = sha256Hex(JSON.stringify(headers.requestBody));
+        if (rq !== binding.requestHash) {
+            return { valid: false, reason: "Request body hash mismatch" };
+        }
+    }
+    const claimed = await claimNonceOnce(binding.nonce);
+    if (!claimed)
+        return { valid: false, reason: "Nonce already consumed (replay)" };
+    return { valid: true };
+}

package/dist/protocol/replay-guard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/protocol/replay-guard.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import { hmacSign, verifyHmac } from "./crypto.js";
+describe("replay binding signature", () => {
+    it("verifyHmac is timing-safe compatible", () => {
+        const payload = JSON.stringify({ bindingId: "rb_abc", nonce: "n1" });
+        const sig = hmacSign(payload);
+        expect(verifyHmac(payload, sig)).toBe(true);
+        expect(verifyHmac(payload, sig + "0")).toBe(false);
+    });
+});

package/dist/protocol/security-audit.d.ts

@@ -0,0 +1,18 @@
+import { getThreatModel } from "./threat-catalog.js";
+export declare function generateSecurityAuditReport(): {
+    auditId: string;
+    suiteVersion: string;
+    auditedAt: string;
+    summary: string;
+    phases: Array<{
+        phase: number;
+        name: string;
+        status: "implemented" | "partial" | "planned";
+    }>;
+    findings: Array<{
+        severity: string;
+        area: string;
+        note: string;
+    }>;
+    threatModel: ReturnType<typeof getThreatModel>;
+};

package/dist/protocol/security-audit.js

@@ -0,0 +1,45 @@
+import { SUITE_VERSION } from "../lib/version.js";
+import { getThreatModel } from "./threat-catalog.js";
+export function generateSecurityAuditReport() {
+    return {
+        auditId: `audit_${Date.now().toString(36)}`,
+        suiteVersion: SUITE_VERSION,
+        auditedAt: new Date().toISOString(),
+        summary: "Protocol v4 modules deployed: identity passport, trust v2, fraud graph, oracle quorum, PoE receipts, reasoning Merkle, escrow FSM, replay bindings, zk stubs, credit bureau.",
+        phases: [
+            { phase: 1, name: "Security audit catalog", status: "implemented" },
+            { phase: 2, name: "Agent identity (DID passport)", status: "implemented" },
+            { phase: 3, name: "TrustScore v2", status: "implemented" },
+            { phase: 4, name: "Fraud detection graph", status: "implemented" },
+            { phase: 5, name: "Trust oracle network", status: "partial" },
+            { phase: 6, name: "Proof of execution", status: "implemented" },
+            { phase: 7, name: "Reasoning audit + Merkle", status: "implemented" },
+            { phase: 8, name: "Escrow FSM", status: "implemented" },
+            { phase: 9, name: "Replay protection", status: "implemented" },
+            { phase: 10, name: "ZK layer", status: "partial" },
+            { phase: 11, name: "Compliance engine", status: "partial" },
+            { phase: 12, name: "Agent credit bureau", status: "implemented" },
+            { phase: 13, name: "Enterprise RBAC/OPA", status: "planned" },
+            { phase: 14, name: "OpenTelemetry", status: "partial" },
+            { phase: 15, name: "K8s / contracts production", status: "planned" },
+        ],
+        findings: [
+            {
+                severity: "info",
+                area: "ZK",
+                note: "ZK proofs are simulated; wire Groth16 verifier before enterprise claims",
+            },
+            {
+                severity: "medium",
+                area: "Oracle",
+                note: "Oracle quorum is simulated; deploy validator set on-chain for BFT",
+            },
+            {
+                severity: "low",
+                area: "Storage",
+                note: "Protocol state is JSON files; migrate to Postgres for multi-tenant scale",
+            },
+        ],
+        threatModel: getThreatModel(),
+    };
+}

package/dist/protocol/store.d.ts

@@ -0,0 +1,5 @@
+export declare function readProtocolStore<T>(name: string, fallback: T): Promise<T>;
+export declare function writeProtocolStore<T>(name: string, data: T): Promise<void>;
+/** Per-agent keyed store (e.g. credit-bureau history by agentId). */
+export declare function readProtocolStoreKey<T>(store: string, key: string, fallback: T): Promise<T>;
+export declare function writeProtocolStoreKey<T>(store: string, key: string, data: T): Promise<void>;

package/dist/protocol/store.js

@@ -0,0 +1,59 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { db } from "../lib/db.js";
+const ROOT_KEY = "__root__";
+const SAFE_STORE_NAME = /^[a-z0-9_-]{1,64}$/;
+const LEGACY_DIR = path.join(process.cwd(), "data", "protocol");
+function assertSafeStoreName(name) {
+    if (!SAFE_STORE_NAME.test(name)) {
+        throw new Error(`Invalid protocol store name: ${name}`);
+    }
+}
+function readKv(store, key) {
+    const row = db
+        .prepare("SELECT value FROM protocol_kv WHERE store = ? AND key = ?")
+        .get(store, key);
+    if (!row)
+        return null;
+    return JSON.parse(row.value);
+}
+function writeKv(store, key, data) {
+    db.prepare("INSERT OR REPLACE INTO protocol_kv (store, key, value, updated_at) VALUES (?, ?, ?, unixepoch())").run(store, key, JSON.stringify(data));
+}
+async function migrateLegacyFile(name) {
+    const file = path.join(LEGACY_DIR, `${name}.json`);
+    try {
+        return JSON.parse(await readFile(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export async function readProtocolStore(name, fallback) {
+    assertSafeStoreName(name);
+    const hit = readKv(name, ROOT_KEY);
+    if (hit != null)
+        return hit;
+    const legacy = await migrateLegacyFile(name);
+    if (legacy != null) {
+        writeKv(name, ROOT_KEY, legacy);
+        return legacy;
+    }
+    return fallback;
+}
+export async function writeProtocolStore(name, data) {
+    assertSafeStoreName(name);
+    writeKv(name, ROOT_KEY, data);
+}
+/** Per-agent keyed store (e.g. credit-bureau history by agentId). */
+export async function readProtocolStoreKey(store, key, fallback) {
+    assertSafeStoreName(store);
+    const hit = readKv(store, key);
+    if (hit != null)
+        return hit;
+    return fallback;
+}
+export async function writeProtocolStoreKey(store, key, data) {
+    assertSafeStoreName(store);
+    writeKv(store, key, data);
+}

package/dist/protocol/threat-catalog.d.ts

@@ -0,0 +1,13 @@
+export type ThreatSurface = {
+    id: string;
+    layer: string;
+    threat: string;
+    mitigations: string[];
+    residualRisk: "low" | "medium" | "high";
+};
+export declare const THREAT_CATALOG: ThreatSurface[];
+export declare function getThreatModel(): {
+    version: string;
+    surfaces: ThreatSurface[];
+    attackCategories: string[];
+};

package/dist/protocol/threat-catalog.js

@@ -0,0 +1,75 @@
+export const THREAT_CATALOG = [
+    {
+        id: "T-REPLAY-01",
+        layer: "Settlement",
+        threat: "Payment signature replay on different resource URL",
+        mitigations: ["replay-bindings", "resourceHash", "nonce consumption", "idempotency-key"],
+        residualRisk: "low",
+    },
+    {
+        id: "T-SYBIL-01",
+        layer: "Identity",
+        threat: "Wallet farming / reputation farming",
+        mitigations: ["erc8004-registration", "trustscore-v2-history", "fraud-graph-clusters"],
+        residualRisk: "medium",
+    },
+    {
+        id: "T-WASH-01",
+        layer: "Fraud",
+        threat: "Wash trading volume inflation",
+        mitigations: ["merchant-trust-score", "fraud-scan", "bond-slash"],
+        residualRisk: "medium",
+    },
+    {
+        id: "T-MCP-01",
+        layer: "Agent",
+        threat: "Tool poisoning / prompt injection via MCP",
+        mitigations: ["mandate-diff", "reasoning-audit-merkle", "guard-allowedHosts"],
+        residualRisk: "medium",
+    },
+    {
+        id: "T-ESCROW-01",
+        layer: "Escrow",
+        threat: "Escrow bypass / race on state transition",
+        mitigations: ["escrow-fsm-valid-transitions", "stateProof-hmac", "semantic-settle"],
+        residualRisk: "low",
+    },
+    {
+        id: "T-ORACLE-01",
+        layer: "Trust",
+        threat: "Centralized trust manipulation",
+        mitigations: ["trust-oracle-quorum", "multi-oracle-consensus", "slashing-note"],
+        residualRisk: "medium",
+    },
+    {
+        id: "T-PII-01",
+        layer: "Compliance",
+        threat: "PII leakage in audit logs",
+        mitigations: ["prompt-hashes-only", "zk-selective-disclosure", "evidence-locker-org-scope"],
+        residualRisk: "low",
+    },
+    {
+        id: "T-DOS-01",
+        layer: "API",
+        threat: "Rate limit exhaustion / unpaid probe abuse",
+        mitigations: ["rate-limit-unpaid", "rate-limit-per-min", "402-on-paid-routes"],
+        residualRisk: "low",
+    },
+];
+export function getThreatModel() {
+    return {
+        version: "4.0.0",
+        surfaces: THREAT_CATALOG,
+        attackCategories: [
+            "replay",
+            "sybil",
+            "wash_trading",
+            "prompt_injection",
+            "tool_poisoning",
+            "escrow_bypass",
+            "oracle_manipulation",
+            "settlement_exploit",
+            "pii_exposure",
+        ],
+    };
+}

package/dist/protocol/trust-oracle.d.ts

@@ -0,0 +1,23 @@
+export type OracleVerifyInput = {
+    subjectType: "agent" | "merchant" | "receipt";
+    subjectId: string;
+    claims: Record<string, unknown>;
+    minQuorum?: number;
+};
+export type OracleConsensusResult = {
+    consensus: boolean;
+    quorum: number;
+    votes: Array<{
+        oracleId: string;
+        approve: boolean;
+        stake: number;
+        reason: string;
+    }>;
+    byzantineFaultTolerance: string;
+    slashingNote: string;
+    proof: {
+        digest: string;
+        signature: string;
+    };
+};
+export declare function runTrustOracleConsensus(input: OracleVerifyInput): Promise<OracleConsensusResult>;

package/dist/protocol/trust-oracle.js

@@ -0,0 +1,30 @@
+import { hmacSign, sha256Hex } from "./crypto.js";
+const ORACLES = ["oracle-a", "oracle-b", "oracle-c", "oracle-d"];
+function oracleVote(oracleId, claims) {
+    const blob = JSON.stringify({ oracleId, claims });
+    const hash = sha256Hex(blob);
+    const n = parseInt(hash.slice(0, 8), 16);
+    const trustClaim = Number(claims.trustScore ?? claims.score ?? 50);
+    const approve = trustClaim >= 40 && n % 7 !== 0;
+    return {
+        oracleId,
+        approve,
+        stake: 100 + (n % 50),
+        reason: approve ? "claims within policy" : "claims failed quorum policy",
+    };
+}
+export async function runTrustOracleConsensus(input) {
+    const quorum = input.minQuorum ?? 3;
+    const votes = ORACLES.map((id) => oracleVote(id, input.claims));
+    const approvals = votes.filter((v) => v.approve).length;
+    const consensus = approvals >= quorum;
+    const digest = sha256Hex(JSON.stringify({ subjectId: input.subjectId, approvals, votes: votes.map((v) => v.oracleId) }));
+    return {
+        consensus,
+        quorum,
+        votes,
+        byzantineFaultTolerance: "tolerates f=1 faulty oracle of 4 (simulated BFT quorum)",
+        slashingNote: "Production: misbehaving oracles lose stake on divergence from on-chain anchor receipts",
+        proof: { digest, signature: hmacSign(digest) },
+    };
+}