feat: push fixed compilation tsconfig

.gitignore

@@ -0,0 +1,8 @@
+node_modules
+cache
+artifacts
+typechain-types
+.env
+coverage
+coverage.json
+*.log

Dockerfile

@@ -0,0 +1,22 @@
+FROM node:22-alpine
+
+WORKDIR /app
+
+# Install build dependencies for native modules
+RUN apk add --no-cache python3 make g++
+
+# Copy dependency mappings and install
+COPY package*.json ./
+RUN npm install
+
+# Copy all project files
+COPY . .
+
+# Compile TS files to dist/
+RUN npx tsc
+
+# Expose port (HF requires this for Docker spaces)
+EXPOSE 7860
+
+# Run the compiled javascript directly for instant boot
+CMD ["node", "dist/scripts/oracle_service.js"]

README.md

@@ -0,0 +1,12 @@
+---
+title: CipherTrust Oracle
+emoji: 🛡️
+colorFrom: yellow
+colorTo: indigo
+sdk: docker
+pinned: false
+---
+
+# CipherTrust Telemetry Oracle Daemon
+
+Background telemetry oracle for the CipherTrust FHE protocol.

contracts/AgentIdentityRegistry.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+/// @title AgentIdentityRegistry
+/// @notice Lightweight, ERC-8004-inspired identity registry for autonomous agents and
+/// robots. This is NOT a claim of full ERC-8004 compliance -- it borrows the standard's
+/// core idea (a portable, on-chain identity record for an autonomous agent, decoupled
+/// from any single application) so CipherTrust's underwriting data, and any other
+/// confidential protocol, can be composed against the same agent identity instead of
+/// re-deriving one per app.
+contract AgentIdentityRegistry {
+    struct Identity {
+        address operator;
+        string agentType; // e.g. "trading-bot", "delivery-robot", "drone", "depin-device"
+        string metadataURI; // off-chain JSON: hardware attestation, manufacturer, firmware hash, etc.
+        uint256 registeredAt;
+        bool active;
+    }
+
+    address public admin;
+    uint256 public nextIdentityId;
+    mapping(uint256 => Identity) public identities;
+    mapping(uint256 => mapping(address => bool)) public delegatedOperators;
+
+    event IdentityRegistered(uint256 indexed identityId, address indexed operator, string agentType);
+    event IdentityDeactivated(uint256 indexed identityId);
+    event OperatorDelegated(uint256 indexed identityId, address indexed delegate);
+
+    modifier onlyOperator(uint256 identityId) {
+        require(
+            identities[identityId].operator == msg.sender || delegatedOperators[identityId][msg.sender],
+            "AgentIdentityRegistry: not operator"
+        );
+        _;
+    }
+
+    constructor() {
+        admin = msg.sender;
+    }
+
+    function registerIdentity(
+        address operator,
+        string calldata agentType,
+        string calldata metadataURI
+    ) external returns (uint256 identityId) {
+        identityId = nextIdentityId++;
+        identities[identityId] = Identity({
+            operator: operator,
+            agentType: agentType,
+            metadataURI: metadataURI,
+            registeredAt: block.timestamp,
+            active: true
+        });
+        emit IdentityRegistered(identityId, operator, agentType);
+    }
+
+    function delegateOperator(uint256 identityId, address delegate) external onlyOperator(identityId) {
+        delegatedOperators[identityId][delegate] = true;
+        emit OperatorDelegated(identityId, delegate);
+    }
+
+    function deactivate(uint256 identityId) external onlyOperator(identityId) {
+        identities[identityId].active = false;
+        emit IdentityDeactivated(identityId);
+    }
+
+    function isActiveOperator(uint256 identityId, address who) external view returns (bool) {
+        Identity storage id_ = identities[identityId];
+        return id_.active && (id_.operator == who || delegatedOperators[identityId][who]);
+    }
+}

contracts/CipherAuth.sol

@@ -0,0 +1,383 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {FHE, euint64, ebool, externalEuint64} from "@fhevm/solidity/lib/FHE.sol";
+import {SepoliaConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+
+contract CipherAuth is SepoliaConfig {
+    // FHE-MFA Biometric Authentication State
+    mapping(address => euint64[3]) private _registeredBiometrics;
+    mapping(address => bool) private _hasBiometrics;
+    uint32 public maxBiometricDrift = 15; // Manhattan distance tolerance
+    mapping(address => bool) public biometricAuthPassed;
+    mapping(uint256 => address) public biometricRequestUser;
+
+    // FHE-Guard: Spam Filtering State
+    mapping(address => uint32) public spamThreshold;
+    mapping(address => uint256) public inboxCount;
+    mapping(address => uint256) public spamInboxCount;
+    mapping(uint256 => address) public spamCheckRequestUser;
+
+    // FHE-Guard: Passwordless Auth State
+    mapping(address => euint64) private _masterSecret;
+    mapping(address => bool) private _hasSecret;
+    mapping(address => uint64) public activeAuthChallenge;
+    mapping(address => bool) public authPassed;
+    mapping(uint256 => address) public authRequests;
+
+    // FHE-Passport: Biometric Uniqueness State
+    uint256 public passportCount;
+    mapping(uint256 => euint64[3]) private _passportDatabase;
+    mapping(address => bool) public hasPassport;
+    mapping(uint256 => address) public passportRequests;
+    mapping(address => bool) public passportUnique;
+    mapping(uint256 => euint64[3]) private _pendingPassportTemplates;
+    uint256 public nextTierRequestId = 1;
+
+    // FHE-Aegis: AI Agent Behavior Drift State
+    mapping(uint256 => euint64[3]) private _agentBaselines;
+    mapping(uint256 => bool) private _hasBaseline;
+    uint32 public maxBehaviorDrift = 1000; // squared Euclidean distance threshold
+    mapping(uint256 => bool) public agentBehaviorCompromised;
+    mapping(uint256 => uint256) public behaviorRequests;
+
+    event BiometricsRegistered(address indexed user);
+    event BiometricsVerified(address indexed user, bool success);
+    event MessageSpamChecked(address indexed recipient, bool isSpam);
+    event AuthSecretRegistered(address indexed user);
+    event AuthChallengeGenerated(address indexed user, uint64 challenge);
+    event AuthVerified(address indexed user, bool success);
+    event PassportCheckRequested(address indexed user, uint256 indexed requestId);
+    event PassportRegistered(address indexed user, bool success, uint256 passportId);
+    event AgentBaselineRegistered(uint256 indexed agentId);
+    event BehaviorCheckRequested(uint256 indexed agentId, uint256 indexed requestId);
+    event BehaviorChecked(uint256 indexed agentId, bool compromised);
+
+    // FHE-MFA: Biometric Authentication Implementation
+    function registerBiometricSignature(
+        externalEuint64 hX,
+        externalEuint64 hY,
+        externalEuint64 hZ,
+        bytes calldata inputProof
+    ) external {
+        _registeredBiometrics[msg.sender][0] = FHE.fromExternal(hX, inputProof);
+        _registeredBiometrics[msg.sender][1] = FHE.fromExternal(hY, inputProof);
+        _registeredBiometrics[msg.sender][2] = FHE.fromExternal(hZ, inputProof);
+        _hasBiometrics[msg.sender] = true;
+
+        FHE.allowThis(_registeredBiometrics[msg.sender][0]);
+        FHE.allowThis(_registeredBiometrics[msg.sender][1]);
+        FHE.allowThis(_registeredBiometrics[msg.sender][2]);
+        FHE.allow(_registeredBiometrics[msg.sender][0], msg.sender);
+        FHE.allow(_registeredBiometrics[msg.sender][1], msg.sender);
+        FHE.allow(_registeredBiometrics[msg.sender][2], msg.sender);
+
+        emit BiometricsRegistered(msg.sender);
+    }
+
+    function requestBiometricAuth(
+        externalEuint64 hX,
+        externalEuint64 hY,
+        externalEuint64 hZ,
+        bytes calldata inputProof
+    ) external returns (uint256 requestId) {
+        address user = msg.sender;
+        require(_hasBiometrics[user]);
+
+        euint64 x = FHE.fromExternal(hX, inputProof);
+        euint64 y = FHE.fromExternal(hY, inputProof);
+        euint64 z = FHE.fromExternal(hZ, inputProof);
+
+        euint64 dX = FHE.select(FHE.lt(x, _registeredBiometrics[user][0]), FHE.sub(_registeredBiometrics[user][0], x), FHE.sub(x, _registeredBiometrics[user][0]));
+        euint64 dY = FHE.select(FHE.lt(y, _registeredBiometrics[user][1]), FHE.sub(_registeredBiometrics[user][1], y), FHE.sub(y, _registeredBiometrics[user][1]));
+        euint64 dZ = FHE.select(FHE.lt(z, _registeredBiometrics[user][2]), FHE.sub(_registeredBiometrics[user][2], z), FHE.sub(z, _registeredBiometrics[user][2]));
+
+        euint64 totalDist = FHE.add(FHE.add(dX, dY), dZ);
+        ebool isValid = FHE.le(totalDist, FHE.asEuint64(maxBiometricDrift));
+        FHE.allowThis(isValid);
+
+        bytes32[] memory cts = new bytes32[](1);
+        cts[0] = ebool.unwrap(isValid);
+
+        requestId = FHE.requestDecryption(cts, this.fulfillBiometricAuth.selector);
+        biometricRequestUser[requestId] = user;
+
+        biometricAuthPassed[user] = false;
+        emit BiometricsVerified(user, false);
+    }
+
+    function fulfillBiometricAuth(
+        uint256 requestId,
+        bytes memory cleartexts,
+        bytes memory decryptionProof
+    ) external {
+        FHE.checkSignatures(requestId, cleartexts, decryptionProof);
+
+        bool success = abi.decode(cleartexts, (bool));
+        address user = biometricRequestUser[requestId];
+        delete biometricRequestUser[requestId];
+
+        biometricAuthPassed[user] = success;
+        emit BiometricsVerified(user, success);
+    }
+
+    // FHE-Guard: Spam Filtering Implementation
+    function setSpamThreshold(uint32 threshold) external {
+        spamThreshold[msg.sender] = threshold;
+    }
+
+    function checkMessageSpam(
+        address recipient,
+        externalEuint64 wA,
+        externalEuint64 wB,
+        externalEuint64 wC,
+        bytes calldata inputProof
+    ) external returns (uint256 requestId) {
+        if (spamThreshold[recipient] == 0) {
+            spamThreshold[recipient] = 15; // default threshold
+        }
+
+        euint64 scoreA = FHE.fromExternal(wA, inputProof);
+        euint64 scoreB = FHE.fromExternal(wB, inputProof);
+        euint64 scoreC = FHE.fromExternal(wC, inputProof);
+
+        euint64 totalScore = FHE.add(FHE.add(scoreA, scoreB), scoreC);
+        ebool isSpam = FHE.gt(totalScore, FHE.asEuint64(spamThreshold[recipient]));
+
+        FHE.allowThis(isSpam);
+
+        bytes32[] memory cts = new bytes32[](1);
+        cts[0] = ebool.unwrap(isSpam);
+
+        requestId = FHE.requestDecryption(cts, this.fulfillSpamCheck.selector);
+        spamCheckRequestUser[requestId] = recipient;
+    }
+
+    function fulfillSpamCheck(
+        uint256 requestId,
+        bytes memory cleartexts,
+        bytes memory decryptionProof
+    ) external {
+        FHE.checkSignatures(requestId, cleartexts, decryptionProof);
+
+        bool isSpam = abi.decode(cleartexts, (bool));
+        address recipient = spamCheckRequestUser[requestId];
+        delete spamCheckRequestUser[requestId];
+
+        if (isSpam) {
+            spamInboxCount[recipient]++;
+        } else {
+            inboxCount[recipient]++;
+        }
+
+        emit MessageSpamChecked(recipient, isSpam);
+    }
+
+    // FHE-Pass: Challenge-Response Implementation
+    function registerAuthSecret(
+        externalEuint64 hSecret,
+        bytes calldata inputProof
+    ) external {
+        _masterSecret[msg.sender] = FHE.fromExternal(hSecret, inputProof);
+        _hasSecret[msg.sender] = true;
+
+        FHE.allowThis(_masterSecret[msg.sender]);
+        FHE.allow(_masterSecret[msg.sender], msg.sender);
+
+        emit AuthSecretRegistered(msg.sender);
+    }
+
+    function generateAuthChallenge(uint64 seedChallenge) external returns (uint64) {
+        require(_hasSecret[msg.sender]);
+        activeAuthChallenge[msg.sender] = seedChallenge;
+        emit AuthChallengeGenerated(msg.sender, seedChallenge);
+        return seedChallenge;
+    }
+
+    function verifyAuthChallenge(
+        externalEuint64 hResponse,
+        bytes calldata inputProof
+    ) external returns (uint256 requestId) {
+        address user = msg.sender;
+        require(_hasSecret[user]);
+        require(activeAuthChallenge[user] != 0);
+
+        euint64 response = FHE.fromExternal(hResponse, inputProof);
+        euint64 challengeVal = FHE.asEuint64(activeAuthChallenge[user]);
+        euint64 expected = FHE.add(_masterSecret[user], challengeVal);
+
+        ebool isValid = FHE.eq(response, expected);
+        FHE.allowThis(isValid);
+
+        bytes32[] memory cts = new bytes32[](1);
+        cts[0] = ebool.unwrap(isValid);
+
+        requestId = FHE.requestDecryption(cts, this.fulfillAuthCheck.selector);
+        authRequests[requestId] = user;
+
+        authPassed[user] = false;
+        emit AuthVerified(user, false);
+    }
+
+    function fulfillAuthCheck(
+        uint256 requestId,
+        bytes memory cleartexts,
+        bytes memory decryptionProof
+    ) external {
+        FHE.checkSignatures(requestId, cleartexts, decryptionProof);
+
+        bool success = abi.decode(cleartexts, (bool));
+        address user = authRequests[requestId];
+        delete authRequests[requestId];
+
+        authPassed[user] = success;
+        emit AuthVerified(user, success);
+    }
+
+    // FHE-Passport: Biometric Uniqueness Check Implementation
+    function requestPassportRegistration(
+        externalEuint64 hX,
+        externalEuint64 hY,
+        externalEuint64 hZ,
+        bytes calldata inputProof
+    ) external returns (uint256 requestId) {
+        address user = msg.sender;
+        require(!hasPassport[user]);
+
+        euint64 x = FHE.fromExternal(hX, inputProof);
+        euint64 y = FHE.fromExternal(hY, inputProof);
+        euint64 z = FHE.fromExternal(hZ, inputProof);
+
+        uint256 nextReqId = nextTierRequestId++;
+        _pendingPassportTemplates[nextReqId][0] = x;
+        _pendingPassportTemplates[nextReqId][1] = y;
+        _pendingPassportTemplates[nextReqId][2] = z;
+
+        FHE.allowThis(_pendingPassportTemplates[nextReqId][0]);
+        FHE.allowThis(_pendingPassportTemplates[nextReqId][1]);
+        FHE.allowThis(_pendingPassportTemplates[nextReqId][2]);
+
+        ebool isUnique = FHE.asEbool(true);
+
+        for (uint256 i = 0; i < passportCount; i++) {
+            euint64 dX = FHE.select(FHE.lt(x, _passportDatabase[i][0]), FHE.sub(_passportDatabase[i][0], x), FHE.sub(x, _passportDatabase[i][0]));
+            euint64 dY = FHE.select(FHE.lt(y, _passportDatabase[i][1]), FHE.sub(_passportDatabase[i][1], y), FHE.sub(y, _passportDatabase[i][1]));
+            euint64 dZ = FHE.select(FHE.lt(z, _passportDatabase[i][2]), FHE.sub(_passportDatabase[i][2], z), FHE.sub(z, _passportDatabase[i][2]));
+
+            euint64 dist = FHE.add(FHE.add(dX, dY), dZ);
+            ebool duplicate = FHE.le(dist, FHE.asEuint64(10));
+            isUnique = FHE.and(isUnique, FHE.not(duplicate));
+        }
+
+        FHE.allowThis(isUnique);
+
+        bytes32[] memory cts = new bytes32[](1);
+        cts[0] = ebool.unwrap(isUnique);
+
+        requestId = FHE.requestDecryption(cts, this.fulfillPassportCheck.selector);
+        passportRequests[requestId] = user;
+    }
+
+    function fulfillPassportCheck(
+        uint256 requestId,
+        bytes memory cleartexts,
+        bytes memory decryptionProof
+    ) external {
+        FHE.checkSignatures(requestId, cleartexts, decryptionProof);
+
+        bool unique = abi.decode(cleartexts, (bool));
+        address user = passportRequests[requestId];
+        delete passportRequests[requestId];
+
+        if (unique) {
+            uint256 id = passportCount++;
+            _passportDatabase[id][0] = _pendingPassportTemplates[requestId][0];
+            _passportDatabase[id][1] = _pendingPassportTemplates[requestId][1];
+            _passportDatabase[id][2] = _pendingPassportTemplates[requestId][2];
+
+            FHE.allowThis(_passportDatabase[id][0]);
+            FHE.allowThis(_passportDatabase[id][1]);
+            FHE.allowThis(_passportDatabase[id][2]);
+
+            hasPassport[user] = true;
+            passportUnique[user] = true;
+            emit PassportRegistered(user, true, id);
+        } else {
+            passportUnique[user] = false;
+            emit PassportRegistered(user, false, 0);
+        }
+    }
+
+    // FHE-Aegis: Behavioral Anomaly Detector Implementation
+    function registerAgentBaseline(
+        uint256 agentId,
+        externalEuint64 hT,
+        externalEuint64 hF,
+        externalEuint64 hC,
+        bytes calldata inputProof
+    ) external {
+        _agentBaselines[agentId][0] = FHE.fromExternal(hT, inputProof);
+        _agentBaselines[agentId][1] = FHE.fromExternal(hF, inputProof);
+        _agentBaselines[agentId][2] = FHE.fromExternal(hC, inputProof);
+        _hasBaseline[agentId] = true;
+
+        FHE.allowThis(_agentBaselines[agentId][0]);
+        FHE.allowThis(_agentBaselines[agentId][1]);
+        FHE.allowThis(_agentBaselines[agentId][2]);
+
+        emit AgentBaselineRegistered(agentId);
+    }
+
+    function evaluateAgentBehavior(
+        uint256 agentId,
+        externalEuint64 hT,
+        externalEuint64 hF,
+        externalEuint64 hC,
+        bytes calldata inputProof
+    ) external returns (uint256 requestId) {
+        require(_hasBaseline[agentId]);
+
+        euint64 oT = FHE.fromExternal(hT, inputProof);
+        euint64 oF = FHE.fromExternal(hF, inputProof);
+        euint64 oC = FHE.fromExternal(hC, inputProof);
+
+        euint64 bT = _agentBaselines[agentId][0];
+        euint64 bF = _agentBaselines[agentId][1];
+        euint64 bC = _agentBaselines[agentId][2];
+
+        euint64 diffT = FHE.select(FHE.lt(oT, bT), FHE.sub(bT, oT), FHE.sub(oT, bT));
+        euint64 diffF = FHE.select(FHE.lt(oF, bF), FHE.sub(bF, oF), FHE.sub(oF, bF));
+        euint64 diffC = FHE.select(FHE.lt(oC, bC), FHE.sub(bC, oC), FHE.sub(oC, bC));
+
+        euint64 drift = FHE.add(
+            FHE.add(FHE.mul(diffT, diffT), FHE.mul(diffF, diffF)),
+            FHE.mul(diffC, diffC)
+        );
+
+        ebool isCompromised = FHE.gt(drift, FHE.asEuint64(maxBehaviorDrift));
+        FHE.allowThis(isCompromised);
+
+        bytes32[] memory cts = new bytes32[](1);
+        cts[0] = ebool.unwrap(isCompromised);
+
+        requestId = FHE.requestDecryption(cts, this.fulfillBehaviorCheck.selector);
+        behaviorRequests[requestId] = agentId;
+
+        emit BehaviorCheckRequested(agentId, requestId);
+    }
+
+    function fulfillBehaviorCheck(
+        uint256 requestId,
+        bytes memory cleartexts,
+        bytes memory decryptionProof
+    ) external {
+        FHE.checkSignatures(requestId, cleartexts, decryptionProof);
+
+        bool isCompromised = abi.decode(cleartexts, (bool));
+        uint256 agentId = behaviorRequests[requestId];
+        delete behaviorRequests[requestId];
+
+        agentBehaviorCompromised[agentId] = isCompromised;
+        emit BehaviorChecked(agentId, isCompromised);
+    }
+}

contracts/CipherTrust.sol

@@ -0,0 +1,824 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {FHE, euint64, ebool, externalEuint64} from "@fhevm/solidity/lib/FHE.sol";
+import {SepoliaConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+
+interface IReputationBadge {
+    function mintOrUpgrade(uint256 agentId, address operator, uint8 tier) external;
+    function tierOf(uint256 agentId) external view returns (uint8);
+}
+
+interface IInsurancePool {
+    function receivePenalty(uint256 agentId) external payable;
+    function delegateCredit(uint256 agentId, uint256 amount) external;
+    function repayCredit(uint256 agentId) external payable;
+}
+
+/**
+ * @title CipherTrust
+ * @notice Confidential underwriting protocol for autonomous agents & robots.
+ *
+ * Autonomous AI trading bots, delivery robots, drone fleets, and DePIN devices
+ * increasingly hold funds and execute tasks without human supervision. There is
+ * no confidential way today to score their reliability and price the
+ * collateral/insurance they must post -- any naive on-chain reputation system
+ * leaks competitively sensitive operational data (uptime, error rates, routes,
+ * strategy performance) to rivals, because blockchains are public by default.
+ *
+ * CipherTrust computes a rolling trust score and a required collateral bond
+ * entirely under Fully Homomorphic Encryption. Operators, insurers, and task
+ * marketplaces can rely on the *outcome* (bond tier, sufficiency check)
+ * without ever seeing the raw encrypted telemetry that produced it.
+ *
+ * v0.2 additions (see docs/COMPETITIVE_ANALYSIS.md for why these were added):
+ *  - Multi-oracle quorum: telemetry only affects the score once N independent
+ *    oracles agree within a round, reducing single-oracle trust assumptions.
+ *  - Async confidential slashing: an oracle can request a confidential SLA
+ *    breach check; the breach flag is decrypted via Zama's public-decrypt +
+ *    signature-verification flow before any penalty is applied on-chain.
+ *  - Optional composability hooks into a soulbound ReputationBadge (public,
+ *    selectively-revealed trust tier) and an InsurancePool (LP yield funded
+ *    by slashing penalties), so other protocols can build on CipherTrust's
+ *    output without ever touching an agent's raw telemetry.
+ *
+ * NOTE: this is an MVP scaffold. Verify every FHE.* call (especially the
+ * makePubliclyDecryptable / checkSignatures async-decrypt flow) against the
+ * exact current version of fhevm-solidity pinned in package.json before
+ * deploying to a live network -- the FHE Solidity API surface evolves
+ * between releases, and this flow has not yet been compiled/tested.
+ */
+contract CipherTrust is SepoliaConfig {
+    address public admin;
+    uint256 public nextAgentId;
+
+    struct Agent {
+        address operator;
+        bool registered;
+        bool active;
+        uint256 identityId; // optional link into AgentIdentityRegistry, 0 if unset
+        euint64 trustScore; // encrypted, 0-1000 scale
+        euint64 requiredBond; // encrypted, wei
+        uint256 postedBond; // public collateral currently deposited (wei)
+        ebool bondSufficient; // encrypted boolean: postedBond >= requiredBond
+        uint256 breachCount; // public count of confirmed SLA breaches
+        uint256 trustScoreVar; // estimation uncertainty variance, initialized to 100 (public)
+        euint64 liquidationThreshold; // encrypted minimum trust score before liquidation
+        uint256 delegatedBond; // public delegated bond amount borrowed from the pool (wei)
+        uint256 interestAccumulated; // public interest accumulated (wei)
+        uint256 lastInterestUpdateTime; // timestamp of the last yield accrual
+    }
+
+    struct Task {
+        uint256 agentId;
+        address client;
+        uint256 coverageLimit; // maximum ETH coverage (wei)
+        bool active;
+    }
+
+    struct Lease {
+        address lessee;
+        uint256 agentId;
+        uint256 hardwareId;
+        uint256 requiredBond; // underwriting bond (wei)
+        uint256 startTimestamp;
+        bool active;
+    }
+
+    uint256 public nextTaskId = 1;
+    mapping(uint256 => Task) public tasks;
+
+    uint256 public nextLeaseId = 1;
+    mapping(uint256 => Lease) public leases;
+    mapping(address => uint256) public userActiveLeaseId;
+    mapping(uint256 => uint256) public claimRequestTask; // decryption requestId => taskId
+    mapping(uint256 => uint256) public agentActiveTaskId; // agentId => active taskId (0 if none)
+
+    struct PendingRound {
+        uint32 count;
+        bool initialized;
+        euint64 sumCompletion;
+        euint64 sumUptime;
+        euint64 sumLatency;
+        euint64 sumError;
+    }
+
+    mapping(uint256 => Agent) private _agents;
+    mapping(address => bool) public authorizedOracles;
+    mapping(address => bool) public authorizedUnderwriters;
+
+    // FHE-Stream: Confidential Staking Yields & Payroll Streams
+    struct SalaryStream {
+        euint64 flowRate;
+        uint256 lastClaimBlock;
+        bool active;
+    }
+    mapping(address => SalaryStream) private _salaryStreams;
+    mapping(uint256 => address) public streamRequests;
+
+    mapping(uint256 => PendingRound) private _pendingRounds; // agentId => in-flight quorum round
+    mapping(uint256 => uint256) public currentRoundId; // agentId => round id
+    mapping(uint256 => mapping(address => uint256)) private _oracleLastRound; // agentId => oracle => last round id + 1 submitted
+    uint32 public quorumThreshold = 1; // number of independent oracles required per round
+
+    uint256 public nextTierRequestId = 1;
+    mapping(uint256 => uint256) public tierRequestAgent;
+    mapping(uint256 => bytes32) public tierRequestHandle;
+
+    uint256 public nextSlashRequestId = 1;
+    mapping(uint256 => uint256) public slashRequestAgent;
+    mapping(uint256 => bytes32) public slashRequestHandle;
+
+    uint256 public nextLiquidationRequestId = 1;
+    mapping(uint256 => uint256) public liquidationRequestAgent;
+
+    IReputationBadge public reputationBadge;
+    IInsurancePool public insurancePool;
+
+    // FHE-ML Neural Perceptron Weights (Underwriter Configurable)
+    uint32 public weightCompletion = 40;
+    uint32 public weightUptime = 30;
+    uint32 public weightLatency = 15;
+    uint32 public weightError = 80;
+    uint32 public neuronBias = 200;
+    uint32 public maxNeuralRiskThreshold = 1200; // ReLU risk limit
+
+    uint64 private constant W_COMPLETION = 40;
+    uint64 private constant W_UPTIME = 30;
+    uint64 private constant W_LATENCY = 15;
+    uint64 private constant W_ERROR = 15;
+
+    uint64 private constant HIGH_TRUST_THRESHOLD = 750;
+    uint64 private constant MED_TRUST_THRESHOLD = 400;
+
+    uint64 private constant HIGH_TRUST_BOND = uint64(0.1 ether);
+    uint64 private constant MED_TRUST_BOND = uint64(1 ether);
+    uint64 private constant LOW_TRUST_BOND = uint64(5 ether);
+
+    uint256 private constant SLASH_BPS = 1000; // 10% of posted bond
+    uint256 private constant ORACLE_VAR = 50;
+    uint256 private constant PREMIUM_PER_VAR_WEI = 0.04 ether; // 0.04 ETH per unit of variance
+
+    event AgentRegistered(uint256 indexed agentId, address indexed operator, uint256 identityId);
+    event OracleAuthorized(address indexed oracle);
+    event UnderwriterAuthorized(address indexed underwriter);
+    event TelemetrySubmitted(uint256 indexed agentId, address indexed oracle, uint256 roundId);
+    event ScoreUpdated(uint256 indexed agentId, uint256 roundId);
+    event BondDeposited(uint256 indexed agentId, uint256 amount, uint256 totalPosted);
+    event BondWithdrawn(uint256 indexed agentId, uint256 amount);
+    event TierRevealRequested(uint256 indexed agentId, uint256 indexed requestId);
+    event TierRevealed(uint256 indexed agentId, uint64 tierCode);
+    event SlashCheckRequested(uint256 indexed agentId, uint256 indexed requestId);
+    event SlashCheckFulfilled(uint256 indexed agentId, bool breached);
+    event AgentSlashed(uint256 indexed agentId, uint256 penalty);
+    event AgentLiquidated(uint256 indexed agentId, uint256 slashedAmount);
+    event LiquidationCheckRequested(uint256 indexed agentId, uint256 indexed requestId);
+    event TaskRegistered(uint256 indexed taskId, uint256 indexed agentId, address indexed client, uint256 coverageLimit);
+    event ClaimPaid(uint256 indexed taskId, uint256 indexed agentId, address indexed client, uint256 payoutAmount);
+    event NeuronWeightsUpdated(uint32 wComp, uint32 wUpt, uint32 wLat, uint32 wErr, uint32 bias, uint32 threshold);
+    event ReputationBadgeSet(address indexed badge);
+    event InsurancePoolSet(address indexed pool);
+    event LeaseRequested(uint256 indexed leaseId, address indexed lessee, uint256 hardwareId, uint256 requiredBond);
+    event LeaseSettled(uint256 indexed leaseId, address indexed lessee, uint256 hardwareId, bool success, uint256 payout);
+    event SalaryStreamCreated(address indexed recipient);
+    event StreamClaimRequested(address indexed recipient, uint256 indexed requestId);
+    event StreamClaimed(address indexed recipient, uint256 amount);
+
+    modifier onlyAdmin() {
+        require(msg.sender == admin);
+        _;
+    }
+
+    modifier onlyOracle() {
+        require(authorizedOracles[msg.sender]);
+        _;
+    }
+
+    modifier onlyAgentOperator(uint256 agentId) {
+        require(_agents[agentId].operator == msg.sender);
+        _;
+    }
+
+    constructor() {
+        admin = msg.sender;
+    }
+
+    function setQuorumThreshold(uint32 threshold) external onlyAdmin {
+        require(threshold >= 1);
+        quorumThreshold = threshold;
+    }
+
+    function setReputationBadge(address badge) external onlyAdmin {
+        require(address(reputationBadge) == address(0));
+        reputationBadge = IReputationBadge(badge);
+        emit ReputationBadgeSet(badge);
+    }
+
+    function setInsurancePool(address pool) external onlyAdmin {
+        require(address(insurancePool) == address(0));
+        insurancePool = IInsurancePool(pool);
+        emit InsurancePoolSet(pool);
+    }
+
+    function authorizeOracle(address oracle) external onlyAdmin {
+        authorizedOracles[oracle] = true;
+        emit OracleAuthorized(oracle);
+    }
+
+    function authorizeUnderwriter(address underwriter) external onlyAdmin {
+        authorizedUnderwriters[underwriter] = true;
+        emit UnderwriterAuthorized(underwriter);
+    }
+
+    /// @notice Register a new autonomous agent/robot under a given operator.
+    /// @param identityId optional AgentIdentityRegistry id (0 if not using the registry).
+    function registerAgent(address operator, uint256 identityId) external onlyAdmin returns (uint256 agentId) {
+        agentId = nextAgentId++;
+        Agent storage a = _agents[agentId];
+        a.operator = operator;
+        a.registered = true;
+        a.active = true;
+        a.identityId = identityId;
+        a.trustScore = FHE.asEuint64(500); // neutral starting score
+        a.trustScoreVar = 100;
+        a.liquidationThreshold = FHE.asEuint64(300);
+        a.requiredBond = _deriveBond(a.trustScore, 100);
+        a.delegatedBond = 0;
+        a.interestAccumulated = 0;
+        a.lastInterestUpdateTime = block.timestamp;
+
+        FHE.allowThis(a.trustScore);
+        FHE.allowThis(a.requiredBond);
+        FHE.allowThis(a.liquidationThreshold);
+        FHE.allow(a.trustScore, operator);
+        FHE.allow(a.requiredBond, operator);
+        FHE.allow(a.liquidationThreshold, operator);
+
+        emit AgentRegistered(agentId, operator, identityId);
+    }
+
+    /// @notice Submit fully-encrypted telemetry for a completed task. Only
+    /// authorized oracles may call this. The submission only affects the
+    /// agent's score once `quorumThreshold` independent oracles have
+    /// submitted within the current round.
+    function submitTelemetry(
+        uint256 agentId,
+        externalEuint64 completionScoreA,
+        externalEuint64 completionScoreB,
+        externalEuint64 uptimeScore,
+        externalEuint64 latencyScore,
+        externalEuint64 errorScore,
+        bytes calldata inputProof
+    ) external onlyOracle {
+        Agent storage a = _agents[agentId];
+        require(a.registered && a.active);
+
+        uint256 roundId = currentRoundId[agentId];
+        require(_oracleLastRound[agentId][msg.sender] != roundId + 1);
+        _oracleLastRound[agentId][msg.sender] = roundId + 1;
+
+        euint64 compA = FHE.fromExternal(completionScoreA, inputProof);
+        euint64 compB = FHE.fromExternal(completionScoreB, inputProof);
+        euint64 uptime = FHE.fromExternal(uptimeScore, inputProof);
+        euint64 latency = FHE.fromExternal(latencyScore, inputProof);
+        euint64 errorP = FHE.fromExternal(errorScore, inputProof);
+
+        // Compute absolute differences for anomaly detection (Completion only)
+        ebool compAltB = FHE.lt(compA, compB);
+        euint64 compDiff = FHE.select(compAltB, FHE.sub(compB, compA), FHE.sub(compA, compB));
+        ebool compAnomaly = FHE.gt(compDiff, FHE.asEuint64(2));
+
+        // Apply sensor fusion outlier filter
+        euint64 completion = FHE.select(compAnomaly, FHE.asEuint64(0), FHE.div(FHE.add(compA, compB), 2));
+        uptime = FHE.select(compAnomaly, FHE.asEuint64(0), uptime);
+        latency = FHE.select(compAnomaly, FHE.asEuint64(0), latency);
+        errorP = FHE.select(compAnomaly, FHE.asEuint64(10), errorP);
+
+        PendingRound storage round = _pendingRounds[agentId];
+        if (!round.initialized) {
+            round.sumCompletion = completion;
+            round.sumUptime = uptime;
+            round.sumLatency = latency;
+            round.sumError = errorP;
+            round.initialized = true;
+        } else {
+            round.sumCompletion = FHE.add(round.sumCompletion, completion);
+            round.sumUptime = FHE.add(round.sumUptime, uptime);
+            round.sumLatency = FHE.add(round.sumLatency, latency);
+            round.sumError = FHE.add(round.sumError, errorP);
+        }
+        round.count += 1;
+        FHE.allowThis(round.sumCompletion);
+        FHE.allowThis(round.sumUptime);
+        FHE.allowThis(round.sumLatency);
+        FHE.allowThis(round.sumError);
+
+        emit TelemetrySubmitted(agentId, msg.sender, roundId);
+
+        if (round.count >= quorumThreshold) {
+            euint64 avgCompletion = FHE.div(round.sumCompletion, quorumThreshold);
+            euint64 avgUptime = FHE.div(round.sumUptime, quorumThreshold);
+            euint64 avgLatency = FHE.div(round.sumLatency, quorumThreshold);
+            euint64 avgError = FHE.div(round.sumError, quorumThreshold);
+
+            _applyScoreUpdate(agentId, avgCompletion, avgUptime, avgLatency, avgError);
+
+            delete _pendingRounds[agentId];
+            currentRoundId[agentId] = roundId + 1;
+            emit ScoreUpdated(agentId, roundId);
+        }
+    }
+
+    function _applyScoreUpdate(
+        uint256 agentId,
+        euint64 completion,
+        euint64 uptime,
+        euint64 latency,
+        euint64 errorP
+    ) private {
+        Agent storage a = _agents[agentId];
+
+        euint64 weightedObs = FHE.add(
+            FHE.add(FHE.mul(completion, W_COMPLETION), FHE.mul(uptime, W_UPTIME)),
+            FHE.mul(latency, W_LATENCY)
+        );
+        euint64 penalty = FHE.mul(errorP, W_ERROR);
+
+        ebool obsUnderflow = FHE.lt(weightedObs, penalty);
+        euint64 x_obs = FHE.select(obsUnderflow, FHE.asEuint64(0), FHE.sub(weightedObs, penalty));
+
+        // Bayesian Update for variance and weights
+        uint256 oldVar = a.trustScoreVar;
+        uint256 newVar = (oldVar * ORACLE_VAR) / (oldVar + ORACLE_VAR);
+        if (newVar < 10) {
+            newVar = 10;
+        }
+        a.trustScoreVar = newVar;
+
+        uint256 alpha = (ORACLE_VAR * 100) / (oldVar + ORACLE_VAR);
+        uint256 beta = (oldVar * 100) / (oldVar + ORACLE_VAR);
+
+        // Weighted FHE score update
+        euint64 term1 = FHE.mul(a.trustScore, uint64(alpha));
+        euint64 term2 = FHE.mul(x_obs, uint64(beta));
+        euint64 newScore = FHE.div(FHE.add(term1, term2), 100);
+
+        a.trustScore = newScore;
+        a.requiredBond = _deriveBond(newScore, newVar);
+
+        uint256 dt = block.timestamp - a.lastInterestUpdateTime;
+        a.lastInterestUpdateTime = block.timestamp;
+        if (dt > 0 && a.delegatedBond > 0) {
+            uint256 apr = 500; // default 5% APR
+            if (address(reputationBadge) != address(0)) {
+                uint8 tier = reputationBadge.tierOf(agentId);
+                if (tier == 3) apr = 100;
+                else if (tier == 2) apr = 500;
+                else if (tier == 1) apr = 2500;
+            }
+            uint256 interestAcc = (a.delegatedBond * apr * dt) / 8640000000;
+            a.interestAccumulated += interestAcc;
+        }
+
+        euint64 totalCollateral = FHE.add(FHE.asEuint64(uint64(_clampToU64(a.postedBond))), FHE.asEuint64(uint64(_clampToU64(a.delegatedBond))));
+        a.bondSufficient = FHE.ge(totalCollateral, a.requiredBond);
+
+        FHE.allowThis(a.trustScore);
+        FHE.allowThis(a.requiredBond);
+        FHE.allowThis(a.bondSufficient);
+        FHE.allow(a.trustScore, a.operator);
+        FHE.allow(a.requiredBond, a.operator);
+        // On-chain FHE Perceptron (Confidential AI Model Inference)
+        euint64 positiveRisk = FHE.add(
+            FHE.add(FHE.mul(latency, weightLatency), FHE.mul(errorP, weightError)),
+            FHE.asEuint64(neuronBias)
+        );
+        euint64 negativeRisk = FHE.add(
+            FHE.mul(completion, weightCompletion),
+            FHE.mul(uptime, weightUptime)
+        );
+        
+        ebool riskUnderflow = FHE.lt(positiveRisk, negativeRisk);
+        euint64 neuralRisk = FHE.select(riskUnderflow, FHE.asEuint64(0), FHE.sub(positiveRisk, negativeRisk));
+        ebool isNeuralBreach = FHE.gt(neuralRisk, FHE.asEuint64(maxNeuralRiskThreshold));
+
+        ebool breachedLimit = FHE.or(FHE.lt(newScore, a.liquidationThreshold), isNeuralBreach);
+        euint64 severity = FHE.sub(FHE.asEuint64(1000), newScore);
+
+        bytes32[] memory cts = new bytes32[](2);
+        cts[0] = ebool.unwrap(breachedLimit);
+        cts[1] = euint64.unwrap(severity);
+        
+        uint256 reqId = FHE.requestDecryption(cts, this.fulfillLiquidation.selector);
+        liquidationRequestAgent[reqId] = agentId;
+        emit LiquidationCheckRequested(agentId, reqId);
+    }
+
+    /// @dev Confidential decision-tree: three bond tiers selected entirely
+    /// under encryption via FHE.select, plus a dynamic uncertainty premium.
+    function _deriveBond(euint64 score, uint256 variance) private returns (euint64) {
+        ebool highTrust = FHE.ge(score, FHE.asEuint64(HIGH_TRUST_THRESHOLD));
+        ebool medTrust = FHE.ge(score, FHE.asEuint64(MED_TRUST_THRESHOLD));
+
+        euint64 baseBond = FHE.select(medTrust, FHE.asEuint64(MED_TRUST_BOND), FHE.asEuint64(LOW_TRUST_BOND));
+        baseBond = FHE.select(highTrust, FHE.asEuint64(HIGH_TRUST_BOND), baseBond);
+
+        uint256 premium = variance * PREMIUM_PER_VAR_WEI;
+        return FHE.add(baseBond, FHE.asEuint64(uint64(premium)));
+    }
+
+    function _clampToU64(uint256 value) private pure returns (uint256) {
+        uint256 maxU64 = type(uint64).max;
+        return value > maxU64 ? maxU64 : value;
+    }
+
+    /// @notice Operator posts native-token collateral for an agent.
+    function depositBond(uint256 agentId) external payable onlyAgentOperator(agentId) {
+        require(msg.value > 0);
+        Agent storage a = _agents[agentId];
+        a.postedBond += msg.value;
+        a.bondSufficient = FHE.ge(FHE.asEuint64(uint64(_clampToU64(a.postedBond))), a.requiredBond);
+        FHE.allowThis(a.bondSufficient);
+        FHE.allow(a.bondSufficient, a.operator);
+        emit BondDeposited(agentId, msg.value, a.postedBond);
+    }
+
+    /// @notice Operator withdraws excess collateral. Confidential sufficiency
+    /// should be re-checked off-chain via the relayer SDK before withdrawing,
+    /// since the exact required bond stays encrypted on-chain.
+    function withdrawBond(uint256 agentId, uint256 amount) external onlyAgentOperator(agentId) {
+        Agent storage a = _agents[agentId];
+        require(amount <= a.postedBond);
+        a.postedBond -= amount;
+        a.bondSufficient = FHE.ge(FHE.asEuint64(uint64(_clampToU64(a.postedBond))), a.requiredBond);
+        FHE.allowThis(a.bondSufficient);
+        FHE.allow(a.bondSufficient, a.operator);
+        payable(msg.sender).transfer(amount);
+        emit BondWithdrawn(agentId, amount);
+    }
+
+    /// @notice Grant an authorized underwriter/insurer read access to an
+    /// agent's encrypted trust score, required bond, and sufficiency flag --
+    /// without exposing the raw telemetry that produced them.
+    function grantUnderwriterAccess(uint256 agentId, address underwriter) external onlyAgentOperator(agentId) {
+        require(authorizedUnderwriters[underwriter]);
+        Agent storage a = _agents[agentId];
+        FHE.allow(a.trustScore, underwriter);
+        FHE.allow(a.requiredBond, underwriter);
+        FHE.allow(a.bondSufficient, underwriter);
+    }
+
+    /// @notice Operator opts in to publicly reveal only the *tier* (Low/Medium/High)
+    /// of their agent's trust score -- never the exact score -- so a soulbound
+    /// ReputationBadge can be minted/upgraded. This is a selective disclosure,
+    /// not a default: the raw score stays encrypted unless the operator calls this.
+    function requestTierReveal(uint256 agentId) external onlyAgentOperator(agentId) returns (uint256 requestId) {
+        Agent storage a = _agents[agentId];
+        ebool highTrust = FHE.ge(a.trustScore, FHE.asEuint64(HIGH_TRUST_THRESHOLD));
+        ebool medTrust = FHE.ge(a.trustScore, FHE.asEuint64(MED_TRUST_THRESHOLD));
+        euint64 tierCode = FHE.select(highTrust, FHE.asEuint64(3), FHE.select(medTrust, FHE.asEuint64(2), FHE.asEuint64(1)));
+
+        bytes32[] memory cts = new bytes32[](1);
+        cts[0] = euint64.unwrap(tierCode);
+        requestId = FHE.requestDecryption(cts, this.fulfillTierReveal.selector);
+
+        tierRequestAgent[requestId] = agentId;
+        emit TierRevealRequested(agentId, requestId);
+    }
+
+    /// @notice Called with the Zama KMS's decrypted cleartext + proof (via the
+    /// relayer SDK's public-decrypt flow) to finalize a tier reveal.
+    function fulfillTierReveal(uint256 requestId, bytes memory cleartexts, bytes memory decryptionProof) external {
+        FHE.checkSignatures(requestId, cleartexts, decryptionProof);
+
+        uint64 tierCode = abi.decode(cleartexts, (uint64));
+        uint256 agentId = tierRequestAgent[requestId];
+        delete tierRequestAgent[requestId];
+
+        if (address(reputationBadge) != address(0)) {
+            reputationBadge.mintOrUpgrade(agentId, _agents[agentId].operator, uint8(tierCode));
+        }
+        emit TierRevealed(agentId, tierCode);
+    }
+
+    /// @notice An authorized oracle flags a possible SLA breach with an
+    /// encrypted 0/1 signal. Nothing happens on-chain until the flag is
+    /// confidentially checked and revealed via fulfillSlashCheck.
+    function requestSlashCheck(
+        uint256 agentId,
+        externalEuint64 breachSignal,
+        bytes calldata inputProof
+    ) external onlyOracle returns (uint256 requestId) {
+        Agent storage a = _agents[agentId];
+        require(a.registered);
+
+        euint64 signal = FHE.fromExternal(breachSignal, inputProof);
+        ebool breached = FHE.eq(signal, FHE.asEuint64(1));
+
+        bytes32[] memory cts = new bytes32[](1);
+        cts[0] = ebool.unwrap(breached);
+        requestId = FHE.requestDecryption(cts, this.fulfillSlashCheck.selector);
+
+        slashRequestAgent[requestId] = agentId;
+        emit SlashCheckRequested(agentId, requestId);
+    }
+
+    /// @notice Finalizes a slash check using the Zama KMS's decrypted
+    /// cleartext + proof. If breached, 10% of the posted bond is slashed and
+    /// forwarded to the InsurancePool (if configured) as LP yield.
+    function fulfillSlashCheck(uint256 requestId, bytes memory cleartexts, bytes memory decryptionProof) external {
+        FHE.checkSignatures(requestId, cleartexts, decryptionProof);
+
+        bool breached = abi.decode(cleartexts, (bool));
+        uint256 agentId = slashRequestAgent[requestId];
+        delete slashRequestAgent[requestId];
+
+        if (breached) {
+            Agent storage a = _agents[agentId];
+            uint256 penalty = (a.postedBond * SLASH_BPS) / 10000;
+            if (penalty > 0) {
+                a.postedBond -= penalty;
+                a.breachCount += 1;
+                a.bondSufficient = FHE.ge(FHE.asEuint64(uint64(_clampToU64(a.postedBond))), a.requiredBond);
+                FHE.allowThis(a.bondSufficient);
+                FHE.allow(a.bondSufficient, a.operator);
+
+                if (address(insurancePool) != address(0)) {
+                    insurancePool.receivePenalty{value: penalty}(agentId);
+                }
+                emit AgentSlashed(agentId, penalty);
+            }
+        }
+        emit SlashCheckFulfilled(agentId, breached);
+    }
+
+    /// @notice Finalizes a liquidation check using the Zama KMS's decrypted
+    /// cleartext + proof. If breached, the agent is deactivated and its remaining
+    /// posted bond is fully slashed to the InsurancePool.
+    function fulfillLiquidation(uint256 requestId, bytes memory cleartexts, bytes memory decryptionProof) external {
+        FHE.checkSignatures(requestId, cleartexts, decryptionProof);
+
+        (bool breached, uint256 severity) = abi.decode(cleartexts, (bool, uint256));
+        uint256 agentId = liquidationRequestAgent[requestId];
+        delete liquidationRequestAgent[requestId];
+
+        if (breached) {
+            Agent storage a = _agents[agentId];
+            a.active = false;
+
+            uint256 selfBond = a.postedBond;
+            uint256 borrowedBond = a.delegatedBond;
+
+            a.postedBond = 0;
+            a.delegatedBond = 0;
+            a.bondSufficient = FHE.asEbool(false);
+            FHE.allowThis(a.bondSufficient);
+            FHE.allow(a.bondSufficient, a.operator);
+
+            uint256 totalBond = selfBond + borrowedBond;
+            uint256 payoutAmount = 0;
+            uint256 taskId = agentActiveTaskId[agentId];
+
+            if (taskId > 0 && tasks[taskId].active) {
+                payoutAmount = (tasks[taskId].coverageLimit * severity) / 1000;
+                if (payoutAmount > totalBond) {
+                    payoutAmount = totalBond;
+                }
+                
+                Task storage t = tasks[taskId];
+                t.active = false;
+                agentActiveTaskId[agentId] = 0;
+                
+                if (payoutAmount > 0) {
+                    payable(t.client).transfer(payoutAmount);
+                    emit ClaimPaid(taskId, agentId, t.client, payoutAmount);
+                }
+            }
+
+            uint256 remainder = totalBond - payoutAmount;
+            if (remainder > 0) {
+                if (address(insurancePool) != address(0)) {
+                    insurancePool.receivePenalty{value: remainder}(agentId);
+                }
+                emit AgentLiquidated(agentId, remainder);
+            }
+        }
+    }
+
+    function getAgent(uint256 agentId)
+        external
+        view
+        returns (address operator, bool registered, bool active, uint256 postedBond, uint256 breachCount, uint256 identityId, uint256 trustScoreVar)
+    {
+        Agent storage a = _agents[agentId];
+        return (a.operator, a.registered, a.active, a.postedBond, a.breachCount, a.identityId, a.trustScoreVar);
+    }
+
+    function getEncryptedTrustScore(uint256 agentId) external view returns (euint64) {
+        return _agents[agentId].trustScore;
+    }
+
+    function getEncryptedRequiredBond(uint256 agentId) external view returns (euint64) {
+        return _agents[agentId].requiredBond;
+    }
+
+    function getEncryptedBondSufficiency(uint256 agentId) external view returns (ebool) {
+        return _agents[agentId].bondSufficient;
+    }
+
+    function getDelegatedBond(uint256 agentId) external view returns (uint256) {
+        return _agents[agentId].delegatedBond;
+    }
+
+    function getInterestAccumulated(uint256 agentId) external view returns (uint256) {
+        return _agents[agentId].interestAccumulated;
+    }
+
+    event CreditDelegated(uint256 indexed agentId, uint256 amount);
+    event InterestRepaid(uint256 indexed agentId, uint256 amount);
+
+    function requestCreditDelegation(uint256 agentId, uint256 amount) external {
+        Agent storage a = _agents[agentId];
+        require(msg.sender == a.operator);
+        require(a.registered && a.active);
+        require(address(insurancePool) != address(0));
+
+        insurancePool.delegateCredit(agentId, amount);
+
+        a.delegatedBond += amount;
+        euint64 totalCollateral = FHE.add(FHE.asEuint64(uint64(_clampToU64(a.postedBond))), FHE.asEuint64(uint64(_clampToU64(a.delegatedBond))));
+        a.bondSufficient = FHE.ge(totalCollateral, a.requiredBond);
+
+        FHE.allowThis(a.bondSufficient);
+        FHE.allow(a.bondSufficient, a.operator);
+
+        emit CreditDelegated(agentId, amount);
+    }
+
+    function repayInterest(uint256 agentId) external payable {
+        Agent storage a = _agents[agentId];
+        require(a.registered && a.active);
+        require(msg.value > 0);
+
+        if (msg.value >= a.interestAccumulated) {
+            a.interestAccumulated = 0;
+        } else {
+            a.interestAccumulated -= msg.value;
+        }
+
+        insurancePool.repayCredit{value: msg.value}(agentId);
+
+        emit InterestRepaid(agentId, msg.value);
+    }
+
+    function registerUnderwrittenTask(uint256 agentId, address client, uint256 coverageLimit) external returns (uint256 taskId) {
+        Agent storage a = _agents[agentId];
+        require(msg.sender == a.operator || msg.sender == admin);
+        require(a.registered && a.active);
+        require(agentActiveTaskId[agentId] == 0);
+
+        uint256 totalCollateral = a.postedBond + a.delegatedBond;
+        require(totalCollateral >= coverageLimit);
+
+        taskId = nextTaskId++;
+        Task storage t = tasks[taskId];
+        t.agentId = agentId;
+        t.client = client;
+        t.coverageLimit = coverageLimit;
+        t.active = true;
+
+        agentActiveTaskId[agentId] = taskId;
+
+        emit TaskRegistered(taskId, agentId, client, coverageLimit);
+    }
+
+    function deactivateAgent(uint256 agentId) external onlyAdmin {
+        _agents[agentId].active = false;
+    }
+
+    function updateNeuronWeights(
+        uint32 wComp,
+        uint32 wUpt,
+        uint32 wLat,
+        uint32 wErr,
+        uint32 bias,
+        uint32 threshold
+    ) external onlyAdmin {
+        weightCompletion = wComp;
+        weightUptime = wUpt;
+        weightLatency = wLat;
+        weightError = wErr;
+        neuronBias = bias;
+        maxNeuralRiskThreshold = threshold;
+
+        emit NeuronWeightsUpdated(wComp, wUpt, wLat, wErr, bias, threshold);
+    }
+
+    function requestLeaseHardware(
+        uint256 agentId,
+        uint256 hardwareId,
+        uint256 leaseBond
+    ) external returns (uint256 leaseId) {
+        Agent storage a = _agents[agentId];
+        require(msg.sender == a.operator);
+        require(a.registered && a.active);
+        require(address(reputationBadge) != address(0));
+        require(address(insurancePool) != address(0));
+        require(userActiveLeaseId[msg.sender] == 0);
+        
+        uint8 tier = reputationBadge.tierOf(agentId);
+        require(tier >= 2);
+
+        insurancePool.delegateCredit(agentId, leaseBond);
+
+        leaseId = nextLeaseId++;
+        Lease storage l = leases[leaseId];
+        l.lessee = msg.sender;
+        l.agentId = agentId;
+        l.hardwareId = hardwareId;
+        l.requiredBond = leaseBond;
+        l.startTimestamp = block.timestamp;
+        l.active = true;
+
+        userActiveLeaseId[msg.sender] = leaseId;
+
+        emit LeaseRequested(leaseId, msg.sender, hardwareId, leaseBond);
+    }
+
+    function settleLeaseHardware(uint256 leaseId, bool success) external onlyAdmin {
+        Lease storage l = leases[leaseId];
+        require(l.active);
+
+        l.active = false;
+        userActiveLeaseId[l.lessee] = 0;
+
+        uint256 payout = 0;
+        if (!success) {
+            payout = l.requiredBond;
+            payable(admin).transfer(payout);
+        } else {
+            insurancePool.repayCredit{value: l.requiredBond}(l.agentId);
+        }
+
+        emit LeaseSettled(leaseId, l.lessee, l.hardwareId, success, payout);
+    }
+
+    // FHE-Stream: Confidential Salary & Yield Streaming Implementation
+    function createSalaryStream(
+        address recipient,
+        externalEuint64 hRate,
+        bytes calldata inputProof
+    ) external onlyAdmin {
+        require(!_salaryStreams[recipient].active);
+        
+        _salaryStreams[recipient].flowRate = FHE.fromExternal(hRate, inputProof);
+        _salaryStreams[recipient].lastClaimBlock = block.number;
+        _salaryStreams[recipient].active = true;
+
+        FHE.allow(_salaryStreams[recipient].flowRate, recipient);
+        FHE.allowThis(_salaryStreams[recipient].flowRate);
+
+        emit SalaryStreamCreated(recipient);
+    }
+
+    function claimSalaryStream() external returns (uint256 requestId) {
+        address recipient = msg.sender;
+        SalaryStream storage stream = _salaryStreams[recipient];
+        require(stream.active);
+        require(block.number > stream.lastClaimBlock);
+
+        uint256 blocksAccrued = block.number - stream.lastClaimBlock;
+        stream.lastClaimBlock = block.number;
+
+        euint64 accrued = FHE.mul(stream.flowRate, uint64(blocksAccrued));
+        FHE.allowThis(accrued);
+
+        bytes32[] memory cts = new bytes32[](1);
+        cts[0] = euint64.unwrap(accrued);
+
+        requestId = FHE.requestDecryption(cts, this.fulfillStreamClaim.selector);
+        streamRequests[requestId] = recipient;
+
+        emit StreamClaimRequested(recipient, requestId);
+    }
+
+    function fulfillStreamClaim(
+        uint256 requestId,
+        bytes memory cleartexts,
+        bytes memory decryptionProof
+    ) external {
+        FHE.checkSignatures(requestId, cleartexts, decryptionProof);
+
+        uint256 amount = abi.decode(cleartexts, (uint256));
+        address recipient = streamRequests[requestId];
+        delete streamRequests[requestId];
+
+        if (amount > 0) {
+            payable(recipient).transfer(amount);
+        }
+
+        emit StreamClaimed(recipient, amount);
+    }
+
+    receive() external payable {}
+}

contracts/InsurancePool.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+/// @title InsurancePool
+/// @notice Composable underwriting-yield pool. Liquidity providers stake native token and
+/// earn a share of every confidential slashing penalty collected by CipherTrust when an
+/// autonomous agent breaches its SLA. This is a deliberately plain, fully transparent DeFi
+/// primitive that composes with CipherTrust's confidential risk engine without ever needing
+/// to see any agent's encrypted telemetry or trust score -- a concrete demonstration of
+/// Season 3's "Composable Privacy" theme.
+contract InsurancePool {
+    address public admin;
+    address public cipherTrust;
+
+    uint256 public totalShares;
+    uint256 public totalAssets;
+    mapping(address => uint256) public sharesOf;
+
+    event Staked(address indexed provider, uint256 amount, uint256 shares);
+    event Withdrawn(address indexed provider, uint256 amount, uint256 shares);
+    event PenaltyReceived(uint256 indexed agentId, uint256 amount);
+    event CipherTrustSet(address indexed cipherTrust);
+    event CreditDelegated(uint256 indexed agentId, uint256 amount);
+    event CreditRepaid(uint256 indexed agentId, uint256 amount);
+
+    modifier onlyAdmin() {
+        require(msg.sender == admin, "InsurancePool: not admin");
+        _;
+    }
+
+    modifier onlyCipherTrust() {
+        require(msg.sender == cipherTrust, "InsurancePool: not CipherTrust");
+        _;
+    }
+
+    constructor() {
+        admin = msg.sender;
+    }
+
+    function setCipherTrust(address cipherTrust_) external onlyAdmin {
+        require(cipherTrust == address(0), "InsurancePool: already set");
+        cipherTrust = cipherTrust_;
+        emit CipherTrustSet(cipherTrust_);
+    }
+
+    function stake() external payable returns (uint256 shares) {
+        require(msg.value > 0, "InsurancePool: zero stake");
+        shares = totalShares == 0 ? msg.value : (msg.value * totalShares) / totalAssets;
+        totalShares += shares;
+        totalAssets += msg.value;
+        sharesOf[msg.sender] += shares;
+        emit Staked(msg.sender, msg.value, shares);
+    }
+
+    function withdraw(uint256 shares) external {
+        require(shares > 0 && shares <= sharesOf[msg.sender], "InsurancePool: bad shares");
+        uint256 amount = (shares * totalAssets) / totalShares;
+        sharesOf[msg.sender] -= shares;
+        totalShares -= shares;
+        totalAssets -= amount;
+        payable(msg.sender).transfer(amount);
+        emit Withdrawn(msg.sender, amount, shares);
+    }
+
+    /// @notice Called by CipherTrust when a confidential SLA breach results in a slashing
+    /// penalty. The pool grows in value for existing stakers without minting new shares --
+    /// this is the pool's yield.
+    function receivePenalty(uint256 agentId) external payable onlyCipherTrust {
+        totalAssets += msg.value;
+        emit PenaltyReceived(agentId, msg.value);
+    }
+
+    function pricePerShare() external view returns (uint256) {
+        if (totalShares == 0) return 1e18;
+        return (totalAssets * 1e18) / totalShares;
+    }
+
+    function delegateCredit(uint256 agentId, uint256 amount) external onlyCipherTrust {
+        require(totalAssets >= amount, "InsurancePool: insufficient assets for credit delegation");
+        totalAssets -= amount;
+        payable(cipherTrust).transfer(amount);
+        emit CreditDelegated(agentId, amount);
+    }
+
+    function repayCredit(uint256 agentId) external payable onlyCipherTrust {
+        totalAssets += msg.value;
+        emit CreditRepaid(agentId, msg.value);
+    }
+}

contracts/ReputationBadge.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+/// @title ReputationBadge
+/// @notice Soulbound (non-transferable) ERC-721 badge representing an autonomous agent's
+/// *publicly revealed* trust tier -- never the exact encrypted score. CipherTrust's core
+/// contract calls mintOrUpgrade only after the operator opts in to a confidential tier
+/// reveal, so the badge is a public, composable attestation that other protocols
+/// (insurers, marketplaces, DAOs) can check with a single view call, with zero on-chain
+/// exposure of the underlying telemetry or exact score.
+contract ReputationBadge is ERC721 {
+    enum Tier {
+        Unrated,
+        Low,
+        Medium,
+        High
+    }
+
+    address public admin;
+    address public cipherTrust;
+    mapping(uint256 => Tier) public tierOf; // agentId => tier
+    mapping(uint256 => bool) private _minted;
+
+    event CipherTrustSet(address indexed cipherTrust);
+    event BadgeUpgraded(uint256 indexed agentId, Tier tier);
+
+    modifier onlyAdmin() {
+        require(msg.sender == admin, "ReputationBadge: not admin");
+        _;
+    }
+
+    modifier onlyCipherTrust() {
+        require(msg.sender == cipherTrust, "ReputationBadge: not CipherTrust");
+        _;
+    }
+
+    constructor() ERC721("CipherTrust Reputation Badge", "CTRUST") {
+        admin = msg.sender;
+    }
+
+    function setCipherTrust(address cipherTrust_) external onlyAdmin {
+        require(cipherTrust == address(0), "ReputationBadge: already set");
+        cipherTrust = cipherTrust_;
+        emit CipherTrustSet(cipherTrust_);
+    }
+
+    function mintOrUpgrade(uint256 agentId, address operator, uint8 tier) external onlyCipherTrust {
+        if (!_minted[agentId]) {
+            _minted[agentId] = true;
+            _safeMint(operator, agentId);
+        }
+        tierOf[agentId] = Tier(tier);
+        emit BadgeUpgraded(agentId, Tier(tier));
+    }
+
+    function tokenURI(uint256 tokenId) public view override returns (string memory) {
+        _requireOwned(tokenId);
+        Tier tier = tierOf[tokenId];
+        string memory tierName = tier == Tier.High ? "High" : tier == Tier.Medium ? "Medium" : tier == Tier.Low
+            ? "Low"
+            : "Unrated";
+        return
+            string(
+                abi.encodePacked(
+                    "data:application/json;utf8,{\"name\":\"CipherTrust Agent #",
+                    _toString(tokenId),
+                    "\",\"attributes\":[{\"trait_type\":\"Trust Tier\",\"value\":\"",
+                    tierName,
+                    "\"}]}"
+                )
+            );
+    }
+
+    function _update(address to, uint256 tokenId, address auth) internal override returns (address) {
+        address from = _ownerOf(tokenId);
+        require(from == address(0) || to == address(0), "ReputationBadge: soulbound, non-transferable");
+        return super._update(to, tokenId, auth);
+    }
+
+    function _toString(uint256 value) internal pure returns (string memory) {
+        if (value == 0) return "0";
+        uint256 temp = value;
+        uint256 digits;
+        while (temp != 0) {
+            digits++;
+            temp /= 10;
+        }
+        bytes memory buffer = new bytes(digits);
+        while (value != 0) {
+            digits -= 1;
+            buffer[digits] = bytes1(uint8(48 + (value % 10)));
+            value /= 10;
+        }
+        return string(buffer);
+    }
+}

hardhat.config.ts

@@ -0,0 +1,46 @@
+import { HardhatUserConfig } from "hardhat/config";
+import "@nomicfoundation/hardhat-toolbox";
+// import "@fhevm/hardhat-plugin";
+import * as dotenv from "dotenv";
+
+dotenv.config();
+
+const PRIVATE_KEY = process.env.PRIVATE_KEY ?? "";
+const SEPOLIA_RPC_URL = process.env.SEPOLIA_RPC_URL ?? "";
+
+const config: HardhatUserConfig = {
+  solidity: {
+    version: "0.8.24",
+    settings: {
+      optimizer: {
+        enabled: true,
+        runs: 1,
+        details: {
+          yul: true,
+          yulDetails: {
+            stackAllocation: true
+          }
+        }
+      },
+      evmVersion: "cancun",
+      viaIR: true,
+    },
+  },
+  networks: {
+    hardhat: {
+      allowUnlimitedContractSize: true,
+    },
+    sepolia: {
+      url: SEPOLIA_RPC_URL,
+      accounts: PRIVATE_KEY ? [PRIVATE_KEY] : [],
+      chainId: 11155111,
+    },
+    baseSepolia: {
+      url: "https://sepolia.base.org",
+      accounts: PRIVATE_KEY ? [PRIVATE_KEY] : [],
+      chainId: 84532,
+    },
+  },
+};
+
+export default config;

package.json

@@ -0,0 +1,42 @@
+{
+  "name": "cipherpool-fhevm",
+  "version": "0.2.0",
+  "description": "CipherTrust: confidential underwriting protocol for autonomous agents & robots, built on Zama's fhEVM.",
+  "license": "MIT",
+  "scripts": {
+    "compile": "hardhat compile",
+    "test": "hardhat test",
+    "deploy:sepolia": "hardhat run scripts/deploy.ts --network sepolia"
+  },
+  "devDependencies": {
+    "@fhevm/hardhat-plugin": "^0.1.0",
+    "@fhevm/solidity": "^0.8.0",
+    "@fhevm/mock-utils": "0.1.0",
+    "@zama-fhe/oracle-solidity": "^0.1.0",
+    "@zama-fhe/relayer-sdk": "^0.2.0",
+    "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
+    "@nomicfoundation/hardhat-ethers": "^3.0.0",
+    "@nomicfoundation/hardhat-ignition-ethers": "^0.15.0",
+    "@nomicfoundation/hardhat-ignition": "^0.15.0",
+    "@nomicfoundation/ignition-core": "^0.15.0",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
+    "@nomicfoundation/hardhat-toolbox": "^5.0.0",
+    "@nomicfoundation/hardhat-verify": "^2.0.0",
+    "@typechain/ethers-v6": "^0.5.0",
+    "@typechain/hardhat": "^9.0.0",
+    "@types/chai": "^4.2.0",
+    "@types/mocha": "^10.0.10",
+    "chai": "^4.2.0",
+    "dotenv": "^16.4.5",
+    "hardhat": "^2.22.0",
+    "hardhat-gas-reporter": "^1.0.8",
+    "solidity-coverage": "^0.8.1",
+    "ts-node": "^10.9.2",
+    "typechain": "^8.3.0",
+    "typescript": "^5.5.0"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^5.0.2",
+    "ethers": "^6.13.0"
+  }
+}

scripts/deploy.ts

@@ -0,0 +1,23 @@
+import { ethers } from "hardhat";
+
+async function main() {
+  const [deployer] = await ethers.getSigners();
+  console.log("Deploying CipherTrust with account:", deployer.address);
+
+  const CipherTrust = await ethers.getContractFactory("CipherTrust");
+  const cipherTrust = await CipherTrust.deploy();
+  console.log("CipherTrust deploy tx sent. Hash:", cipherTrust.deploymentTransaction()?.hash);
+  await cipherTrust.waitForDeployment();
+  console.log("CipherTrust deployed to:", await cipherTrust.getAddress());
+
+  const CipherAuth = await ethers.getContractFactory("CipherAuth");
+  const cipherAuth = await CipherAuth.deploy();
+  console.log("CipherAuth deploy tx sent. Hash:", cipherAuth.deploymentTransaction()?.hash);
+  await cipherAuth.waitForDeployment();
+  console.log("CipherAuth deployed to:", await cipherAuth.getAddress());
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

scripts/deploy_auth.ts

@@ -0,0 +1,17 @@
+import { ethers } from "hardhat";
+
+async function main() {
+  const [deployer] = await ethers.getSigners();
+  console.log("Deploying CipherAuth with account:", deployer.address);
+
+  const CipherAuth = await ethers.getContractFactory("CipherAuth");
+  const cipherAuth = await CipherAuth.deploy();
+  console.log("CipherAuth deploy tx sent. Hash:", cipherAuth.deploymentTransaction()?.hash);
+  await cipherAuth.waitForDeployment();
+  console.log("CipherAuth deployed to:", await cipherAuth.getAddress());
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

scripts/optimize_contract.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+const path = require('path');
+
+const filePath = path.join(__dirname, '../contracts/CipherTrust.sol');
+let code = fs.readFileSync(filePath, 'utf8');
+
+console.log("Original code length:", code.length);
+
+// Robust replacement of require with strings
+// Matches require(expression, "string") even with nested parentheses inside expression
+let count = 0;
+code = code.replace(/require\s*\(([^;]+?),\s*"[^"]+?"\s*\)/g, (match, p1) => {
+    count++;
+    return `require(${p1.trim()})`;
+});
+
+console.log(`Replaced ${count} require statements.`);
+
+fs.writeFileSync(filePath, code);
+console.log("Optimization complete.");

scripts/oracle_service.ts

@@ -0,0 +1,58 @@
+import { ethers } from "hardhat";
+import * as dotenv from "dotenv";
+import * as http from "http";
+
+dotenv.config();
+
+// HF Spaces compatibility: Respond to health check pings on port 7860
+const port = process.env.PORT || 7860;
+http.createServer((req, res) => {
+  res.writeHead(200, { "Content-Type": "text/plain" });
+  res.end("CipherTrust Oracle Daemon is Running!\n");
+}).listen(port, () => {
+  console.log(`HF Health Check Server listening on port ${port}`);
+});
+
+async function main() {
+  const cipherTrustAddress = process.env.CIPHERTRUST_ADDRESS;
+  if (!cipherTrustAddress) {
+    console.error("Error: CIPHERTRUST_ADDRESS environment variable not set.");
+    process.exit(1);
+  }
+
+  console.log("======================================================================");
+  const provider = new ethers.JsonRpcProvider(process.env.RPC_URL || process.env.SEPOLIA_RPC_URL || "http://localhost:8545");
+  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY || "", provider);
+  console.log(`Starting CipherTrust Telemetry Oracle Daemon: ${wallet.address}`);
+  console.log(`Target Protocol Contract Address: ${cipherTrustAddress}`);
+  console.log("======================================================================");
+
+  // Core execution loop
+  while (true) {
+    try {
+      console.log(`[${new Date().toLocaleTimeString()}] Fetching agent telemetry coordinates...`);
+      
+      // Simulate real-time physical drone telemetry
+      const x = Math.floor(Math.random() * 80) + 10;
+      const y = Math.floor(Math.random() * 80) + 10;
+      
+      // Compute correct distance squares to beacons: A(10,10), B(90,10), C(50,80)
+      const distA = Math.pow(x - 10, 2) + Math.pow(y - 10, 2);
+      const distB = Math.pow(x - 90, 2) + Math.pow(y - 10, 2);
+      const distC = Math.pow(x - 50, 2) + Math.pow(y - 80, 2);
+
+      console.log(`Generated Coordinates: (${x}, ${y}) | DistSq: A=${distA}, B=${distB}, C=${distC}`);
+      console.log("Pushing telemetry update successfully simulated.");
+    } catch (e) {
+      console.error("Error in oracle execution loop:", e);
+    }
+    
+    // Wait for next telemetry submission round (e.g. 60 seconds)
+    await new Promise((resolve) => setTimeout(resolve, 60000));
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

scripts/setup_database.sql

@@ -0,0 +1,58 @@
+-- ==========================================
+-- CipherTrust Protocol: Supabase Database Setup
+-- Run this script inside your Supabase SQL Editor
+-- ==========================================
+
+-- Enable UUID extension for secure random IDs
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+-- Table: Autonomous Agents / Robots Registry
+CREATE TABLE IF NOT EXISTS agents (
+    id SERIAL PRIMARY KEY,
+    agent_id INT UNIQUE NOT NULL,
+    operator_address VARCHAR(42) NOT NULL,
+    registered_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    active BOOLEAN DEFAULT TRUE,
+    trust_variance INT DEFAULT 100,
+    public_reputation_badge VARCHAR(42) DEFAULT NULL
+);
+
+-- Index for agent query optimizations
+CREATE INDEX IF NOT EXISTS idx_agents_operator ON agents(operator_address);
+
+-- Table: Redundant Telemetry Audits
+CREATE TABLE IF NOT EXISTS telemetry_rounds (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    agent_id INT REFERENCES agents(agent_id) ON DELETE CASCADE,
+    round_id INT NOT NULL,
+    submitted_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    sensor_a_reading INT NOT NULL,
+    sensor_b_reading INT NOT NULL,
+    is_anomaly BOOLEAN DEFAULT FALSE
+);
+
+CREATE INDEX IF NOT EXISTS idx_telemetry_agent_round ON telemetry_rounds(agent_id, round_id);
+
+-- Table: Location Triangulation Log
+CREATE TABLE IF NOT EXISTS location_proofs (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    operator_address VARCHAR(42) NOT NULL,
+    calculated_x INT NOT NULL,
+    calculated_y INT NOT NULL,
+    distance_sq_a INT NOT NULL,
+    distance_sq_b INT NOT NULL,
+    distance_sq_c INT NOT NULL,
+    verified BOOLEAN NOT NULL,
+    timestamp TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Table: Multi-Factor Authentication Audits
+CREATE TABLE IF NOT EXISTS auth_audits (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    user_address VARCHAR(42) NOT NULL,
+    auth_type VARCHAR(30) NOT NULL, -- 'biometrics', 'passwordless', 'passport'
+    status VARCHAR(15) NOT NULL, -- 'success', 'failed'
+    timestamp TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_auth_user ON auth_audits(user_address);

scripts/simulate_agent.ts

@@ -0,0 +1,226 @@
+import hre from "hardhat";
+
+async function main() {
+  console.log("======================================================================");
+  console.log("   CipherTrust: Autonomous Agent Flight & Attack Simulation Script    ");
+  console.log("======================================================================\n");
+
+  const [admin, operator, oracle1, oracle2, stranger] = await hre.ethers.getSigners();
+  const ctAddress = "0x0000000000000000000000000000000000000000"; // Mock deploy or real depending on hardhat network
+
+  console.log("[1/6] Deploying CipherTrust Protocol Contract Suite...");
+  const ReputationBadge = await hre.ethers.getContractFactory("ReputationBadge");
+  const reputationBadge = await ReputationBadge.connect(admin).deploy();
+  await reputationBadge.waitForDeployment();
+  console.log(` -> ReputationBadge SB-NFT deployed to: ${await reputationBadge.getAddress()}`);
+
+  const InsurancePool = await hre.ethers.getContractFactory("InsurancePool");
+  const insurancePool = await InsurancePool.connect(admin).deploy();
+  await insurancePool.waitForDeployment();
+  console.log(` -> InsurancePool deployed to: ${await insurancePool.getAddress()}`);
+
+  const CipherTrust = await hre.ethers.getContractFactory("CipherTrust");
+  const cipherTrust = await CipherTrust.connect(admin).deploy();
+  await cipherTrust.waitForDeployment();
+  console.log(` -> CipherTrust Core deployed to: ${await cipherTrust.getAddress()}`);
+
+  // Linked contracts
+  await (await reputationBadge.connect(admin).setCipherTrust(await cipherTrust.getAddress())).wait();
+  await (await insurancePool.connect(admin).setCipherTrust(await cipherTrust.getAddress())).wait();
+  await (await cipherTrust.connect(admin).setReputationBadge(await reputationBadge.getAddress())).wait();
+  await (await cipherTrust.connect(admin).setInsurancePool(await insurancePool.getAddress())).wait();
+
+  // Authorize Oracles
+  await (await cipherTrust.connect(admin).authorizeOracle(oracle1.address)).wait();
+  await (await cipherTrust.connect(admin).authorizeOracle(oracle2.address)).wait();
+  await (await cipherTrust.connect(admin).setQuorumThreshold(2)).wait();
+  console.log(" -> Oracles authorized. Quorum threshold set to 2.\n");
+
+  console.log("[2/6] Initializing Underwriting Capital (InsurancePool Staking)...");
+  // Stranger stakes 10 ETH into the InsurancePool
+  await (await insurancePool.connect(stranger).stake({ value: hre.ethers.parseEther("10") })).wait();
+  console.log(` -> Stranger staked 10 ETH. Insurance Pool Assets: ${hre.ethers.formatEther(await insurancePool.totalAssets())} ETH\n`);
+
+  console.log("[3/6] Registering Autonomous Delivery Drone & Requesting Credit Delegation...");
+  // Register drone agent #0
+  await (await cipherTrust.connect(admin).registerAgent(operator.address, 0)).wait();
+  console.log(" -> Delivery Drone Agent #0 registered.");
+
+  let agent = await cipherTrust.getAgent(0);
+  console.log(` -> Initial Uncertainty Variance (σ²): ${agent.trustScoreVar}`);
+  let reqBond = await hre.fhevm.debugger.decryptEuint(5, await cipherTrust.getEncryptedRequiredBond(0));
+  console.log(` -> Initial Required Collateral Bond: ${hre.ethers.formatEther(reqBond)} ETH`);
+
+  // Operator borrows bond from InsurancePool (Credit Delegation)
+  await (await cipherTrust.connect(operator).requestCreditDelegation(0, hre.ethers.parseEther("5"))).wait();
+  console.log(` -> Borrowed 5 ETH from InsurancePool. Delegated Bond staked: ${hre.ethers.formatEther(await cipherTrust.getDelegatedBond(0))} ETH`);
+  
+  let sufficient = await hre.fhevm.debugger.decryptEbool(await cipherTrust.getEncryptedBondSufficiency(0));
+  console.log(` -> Collateral Sufficiency Status under FHE: ${sufficient ? "SUFFICIENT (Ready for Operations)" : "INSUFFICIENT"}\n`);
+
+  console.log("[4/6] Executing Flight Telemetry Round 1 (Normal Operations)...");
+  // Redundant sensor readings: Sensor A = 9, Sensor B = 9, Uptime = 9, Latency = 9, Error = 0
+  const scoreVal = 9;
+  const errVal = 0;
+  const targetAddress = await cipherTrust.getAddress();
+
+  // Oracle 1 attestation
+  const input1 = hre.fhevm.createEncryptedInput(targetAddress, oracle1.address);
+  input1.add64(scoreVal); // compA
+  input1.add64(scoreVal); // compB
+  input1.add64(scoreVal); // uptime
+  input1.add64(scoreVal); // latency
+  input1.add64(errVal);   // error
+  const encrypted1 = await input1.encrypt();
+  await (
+    await cipherTrust.connect(oracle1).submitTelemetry(
+      0,
+      encrypted1.handles[0],
+      encrypted1.handles[1],
+      encrypted1.handles[2],
+      encrypted1.handles[3],
+      encrypted1.handles[4],
+      encrypted1.inputProof
+    )
+  ).wait();
+
+  // Oracle 2 attestation
+  const input2 = hre.fhevm.createEncryptedInput(targetAddress, oracle2.address);
+  input2.add64(scoreVal);
+  input2.add64(scoreVal);
+  input2.add64(scoreVal);
+  input2.add64(scoreVal);
+  input2.add64(errVal);
+  const encrypted2 = await input2.encrypt();
+  await (
+    await cipherTrust.connect(oracle2).submitTelemetry(
+      0,
+      encrypted2.handles[0],
+      encrypted2.handles[1],
+      encrypted2.handles[2],
+      encrypted2.handles[3],
+      encrypted2.handles[4],
+      encrypted2.inputProof
+    )
+  ).wait();
+
+  // Fast forward block time to simulate operations
+  await hre.ethers.provider.send("evm_increaseTime", [172800]); // 2 days
+  await hre.ethers.provider.send("evm_mine", []);
+
+  agent = await cipherTrust.getAgent(0);
+  let score = await hre.fhevm.debugger.decryptEuint(5, await cipherTrust.getEncryptedTrustScore(0));
+  let bond = await hre.fhevm.debugger.decryptEuint(5, await cipherTrust.getEncryptedRequiredBond(0));
+  let interest = await cipherTrust.getInterestAccumulated(0);
+
+  console.log(` -> Telemetry Round processed. Bayesian Trust Score: ${score}/1000`);
+  console.log(` -> Uncertainty Variance (σ²) decayed to: ${agent.trustScoreVar}`);
+  console.log(` -> Required Bond reduced to: ${hre.ethers.formatEther(bond)} ETH`);
+  console.log(` -> Accumulated Interest accrued to Pool: ${hre.ethers.formatEther(interest)} ETH\n`);
+
+  console.log("[5/6] Simulating GPS Spoofing Attack (Sensor Outlier Filtration)...");
+  // Sensors disagree: Sensor A reports 9 (normal), Sensor B reports 3 (spoofed location drift)
+  const inputAttack1 = hre.fhevm.createEncryptedInput(targetAddress, oracle1.address);
+  inputAttack1.add64(9); // compA (healthy)
+  inputAttack1.add64(3); // compB (spoofed drift > 2)
+  inputAttack1.add64(9); // uptime
+  inputAttack1.add64(9); // latency
+  inputAttack1.add64(0); // error
+  const encryptedAttack1 = await inputAttack1.encrypt();
+  await (
+    await cipherTrust.connect(oracle1).submitTelemetry(
+      0,
+      encryptedAttack1.handles[0],
+      encryptedAttack1.handles[1],
+      encryptedAttack1.handles[2],
+      encryptedAttack1.handles[3],
+      encryptedAttack1.handles[4],
+      encryptedAttack1.inputProof
+    )
+  ).wait();
+
+  const inputAttack2 = hre.fhevm.createEncryptedInput(targetAddress, oracle2.address);
+  inputAttack2.add64(9);
+  inputAttack2.add64(3);
+  inputAttack2.add64(9);
+  inputAttack2.add64(9);
+  inputAttack2.add64(0);
+  const encryptedAttack2 = await inputAttack2.encrypt();
+  await (
+    await cipherTrust.connect(oracle2).submitTelemetry(
+      0,
+      encryptedAttack2.handles[0],
+      encryptedAttack2.handles[1],
+      encryptedAttack2.handles[2],
+      encryptedAttack2.handles[3],
+      encryptedAttack2.handles[4],
+      encryptedAttack2.inputProof
+    )
+  ).wait();
+
+  // Await decryption oracle to run FHE checks
+  await hre.fhevm.awaitDecryptionOracle();
+
+  score = await hre.fhevm.debugger.decryptEuint(5, await cipherTrust.getEncryptedTrustScore(0));
+  console.log(" -> [SUCCESS] Sensor fusion drift check triggered under FHE.");
+  console.log(" -> [SUCCESS] Spoofed Sensor B discarded. Anomaly penalty applied.");
+  console.log(` -> Penalized Bayesian Trust Score: ${score}/1000\n`);
+
+  console.log("[6/6] Simulating Catastrophic Malfunction (FHE Auto-Liquidation)...");
+  // Multiple rounds of failure/errors to push trust score below 300
+  const inputFail1 = hre.fhevm.createEncryptedInput(targetAddress, oracle1.address);
+  inputFail1.add64(1);
+  inputFail1.add64(1);
+  inputFail1.add64(1);
+  inputFail1.add64(1);
+  inputFail1.add64(10); // extreme error rate
+  const encryptedFail1 = await inputFail1.encrypt();
+  await (
+    await cipherTrust.connect(oracle1).submitTelemetry(
+      0,
+      encryptedFail1.handles[0],
+      encryptedFail1.handles[1],
+      encryptedFail1.handles[2],
+      encryptedFail1.handles[3],
+      encryptedFail1.handles[4],
+      encryptedFail1.inputProof
+    )
+  ).wait();
+
+  const inputFail2 = hre.fhevm.createEncryptedInput(targetAddress, oracle2.address);
+  inputFail2.add64(1);
+  inputFail2.add64(1);
+  inputFail2.add64(1);
+  inputFail2.add64(1);
+  inputFail2.add64(10);
+  const encryptedFail2 = await inputFail2.encrypt();
+  await (
+    await cipherTrust.connect(oracle2).submitTelemetry(
+      0,
+      encryptedFail2.handles[0],
+      encryptedFail2.handles[1],
+      encryptedFail2.handles[2],
+      encryptedFail2.handles[3],
+      encryptedFail2.handles[4],
+      encryptedFail2.inputProof
+    )
+  ).wait();
+
+  // Await decryption oracle to finalize liquidation check
+  await hre.fhevm.awaitDecryptionOracle();
+
+  agent = await cipherTrust.getAgent(0);
+  console.log(" -> [SUCCESS] FHE trust score fell below liquidation threshold (300).");
+  console.log(` -> Agent Active Status: ${agent.active ? "ACTIVE" : "INACTIVE / DEACTIVATED"}`);
+  console.log(` -> Slashed Bond remaining: ${hre.ethers.formatEther(agent.postedBond)} ETH`);
+  console.log(` -> Slashed Bond recovered to InsurancePool: ${hre.ethers.formatEther(await insurancePool.totalAssets())} ETH\n`);
+
+  console.log("======================================================================");
+  console.log("               Simulation Completed Successfully!                     ");
+  console.log("======================================================================");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist"
+  },
+  "include": ["./scripts/oracle_service.ts"],
+  "exclude": ["node_modules"]
+}