agentex-creator-sdk 1.0.0

package/dist/packages/contracts/src/watchtower.d.ts

@@ -0,0 +1,1141 @@
+import { z } from 'zod';
+/** Watchtower window contracts (P04 package interface). Kept outside index.ts so modules initialise without a circular import. */
+export declare const WATCH_SCHEMA_ID: "agentex.watchtower-window.v1";
+export declare const WATCH_TOOL: "evm.watch-logs@0.1.0";
+export declare const WATCH_MAX_WINDOW_BLOCKS = 2000;
+export declare const WATCH_MAX_LOGS = 100;
+export declare const WATCH_MAX_RULES = 8;
+export declare const WATCH_RPC_CEILING = 16;
+export declare const WATCH_RPC_METHODS: readonly ["eth_chainId", "eth_getBlockByNumber", "eth_getLogs"];
+export declare const AUTHORITY_EVENTS: readonly ["Upgraded", "AdminChanged", "BeaconUpgraded", "OwnershipTransferred"];
+/** Watchtower 0.3.0: OpenZeppelin/Compound Governor, OpenZeppelin TimelockController and Compound Timelock events. */
+export declare const GOVERNANCE_EVENTS: readonly ["ProposalCreated", "ProposalQueued", "ProposalExecuted", "ProposalCanceled", "CallScheduled", "CallExecuted", "Cancelled", "MinDelayChange", "QueueTransaction", "ExecuteTransaction", "CancelTransaction", "NewDelay", "NewAdmin", "NewPendingAdmin"];
+/** Watchtower 0.3.0: OpenZeppelin AccessControl and Pausable events. */
+export declare const CONTROL_EVENTS: readonly ["RoleGranted", "RoleRevoked", "RoleAdminChanged", "Paused", "Unpaused"];
+/** Watchtower 0.3.0: pool events of Uniswap V2-compatible, Uniswap V3-compatible and Aerodrome (Solidly) pools. */
+export declare const POOL_EVENTS: readonly ["Swap", "Mint", "Burn"];
+export declare const POOL_DEXES: readonly ["uniswap-v2", "uniswap-v3", "aerodrome"];
+/** Rule types added in Watchtower 0.3.0. Versions 0.1.0 and 0.2.0 refuse them, so a pinned monitor never gains a rule its version did not declare. */
+export declare const WATCH_RULES_V3: readonly ["wallet-token-flow", "pool-activity", "governance-change", "control-change"];
+export declare const BlockNumberSchema: z.ZodString;
+export declare const WatchRuleIdSchema: z.ZodString;
+/** Rule types that would need indexes the platform does not have. They fail validation instead of silently matching nothing. */
+export declare const UNSUPPORTED_WATCH_RULES: Readonly<Record<string, string>>;
+export declare const SupportedWatchRuleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"erc20-transfer">;
+    token: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    from: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+    to: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+    minimumAtomic: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"erc20-approval">;
+    token: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    owner: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    spender: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"authority-change">;
+    contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        Upgraded: "Upgraded";
+        AdminChanged: "AdminChanged";
+        BeaconUpgraded: "BeaconUpgraded";
+        OwnershipTransferred: "OwnershipTransferred";
+    }>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"wallet-token-flow">;
+    wallet: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    tokens: z.ZodArray<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+    direction: z.ZodEnum<{
+        out: "out";
+        in: "in";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"pool-activity">;
+    pool: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    dex: z.ZodEnum<{
+        "uniswap-v2": "uniswap-v2";
+        "uniswap-v3": "uniswap-v3";
+        aerodrome: "aerodrome";
+    }>;
+    events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        Swap: "Swap";
+        Mint: "Mint";
+        Burn: "Burn";
+    }>>>;
+    minimumAmount0Atomic: z.ZodOptional<z.ZodString>;
+    minimumAmount1Atomic: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"governance-change">;
+    contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        ProposalCreated: "ProposalCreated";
+        ProposalQueued: "ProposalQueued";
+        ProposalExecuted: "ProposalExecuted";
+        ProposalCanceled: "ProposalCanceled";
+        CallScheduled: "CallScheduled";
+        CallExecuted: "CallExecuted";
+        Cancelled: "Cancelled";
+        MinDelayChange: "MinDelayChange";
+        QueueTransaction: "QueueTransaction";
+        ExecuteTransaction: "ExecuteTransaction";
+        CancelTransaction: "CancelTransaction";
+        NewDelay: "NewDelay";
+        NewAdmin: "NewAdmin";
+        NewPendingAdmin: "NewPendingAdmin";
+    }>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"control-change">;
+    contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        RoleGranted: "RoleGranted";
+        RoleRevoked: "RoleRevoked";
+        RoleAdminChanged: "RoleAdminChanged";
+        Paused: "Paused";
+        Unpaused: "Unpaused";
+    }>>>;
+}, z.core.$strict>], "type">;
+export type WatchRule = z.infer<typeof SupportedWatchRuleSchema>;
+export declare const WatchRuleSchema: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"erc20-transfer">;
+    token: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    from: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+    to: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+    minimumAtomic: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"erc20-approval">;
+    token: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    owner: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    spender: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"authority-change">;
+    contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        Upgraded: "Upgraded";
+        AdminChanged: "AdminChanged";
+        BeaconUpgraded: "BeaconUpgraded";
+        OwnershipTransferred: "OwnershipTransferred";
+    }>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"wallet-token-flow">;
+    wallet: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    tokens: z.ZodArray<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+    direction: z.ZodEnum<{
+        out: "out";
+        in: "in";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"pool-activity">;
+    pool: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    dex: z.ZodEnum<{
+        "uniswap-v2": "uniswap-v2";
+        "uniswap-v3": "uniswap-v3";
+        aerodrome: "aerodrome";
+    }>;
+    events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        Swap: "Swap";
+        Mint: "Mint";
+        Burn: "Burn";
+    }>>>;
+    minimumAmount0Atomic: z.ZodOptional<z.ZodString>;
+    minimumAmount1Atomic: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"governance-change">;
+    contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        ProposalCreated: "ProposalCreated";
+        ProposalQueued: "ProposalQueued";
+        ProposalExecuted: "ProposalExecuted";
+        ProposalCanceled: "ProposalCanceled";
+        CallScheduled: "CallScheduled";
+        CallExecuted: "CallExecuted";
+        Cancelled: "Cancelled";
+        MinDelayChange: "MinDelayChange";
+        QueueTransaction: "QueueTransaction";
+        ExecuteTransaction: "ExecuteTransaction";
+        CancelTransaction: "CancelTransaction";
+        NewDelay: "NewDelay";
+        NewAdmin: "NewAdmin";
+        NewPendingAdmin: "NewPendingAdmin";
+    }>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"control-change">;
+    contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        RoleGranted: "RoleGranted";
+        RoleRevoked: "RoleRevoked";
+        RoleAdminChanged: "RoleAdminChanged";
+        Paused: "Paused";
+        Unpaused: "Unpaused";
+    }>>>;
+}, z.core.$strict>], "type">, unknown>;
+/** One bounded, inclusive block window at or below the latest head. Monitors create consecutive windows; a manual run can inspect one. */
+export declare const WatchtowerWindowInputSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+    }>;
+    fromBlock: z.ZodString;
+    toBlock: z.ZodString;
+    rules: z.ZodArray<z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"erc20-transfer">;
+        token: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        from: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+        to: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+        minimumAtomic: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"erc20-approval">;
+        token: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        owner: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        spender: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"authority-change">;
+        contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            Upgraded: "Upgraded";
+            AdminChanged: "AdminChanged";
+            BeaconUpgraded: "BeaconUpgraded";
+            OwnershipTransferred: "OwnershipTransferred";
+        }>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"wallet-token-flow">;
+        wallet: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        tokens: z.ZodArray<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+        direction: z.ZodEnum<{
+            out: "out";
+            in: "in";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"pool-activity">;
+        pool: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        dex: z.ZodEnum<{
+            "uniswap-v2": "uniswap-v2";
+            "uniswap-v3": "uniswap-v3";
+            aerodrome: "aerodrome";
+        }>;
+        events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            Swap: "Swap";
+            Mint: "Mint";
+            Burn: "Burn";
+        }>>>;
+        minimumAmount0Atomic: z.ZodOptional<z.ZodString>;
+        minimumAmount1Atomic: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"governance-change">;
+        contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            ProposalCreated: "ProposalCreated";
+            ProposalQueued: "ProposalQueued";
+            ProposalExecuted: "ProposalExecuted";
+            ProposalCanceled: "ProposalCanceled";
+            CallScheduled: "CallScheduled";
+            CallExecuted: "CallExecuted";
+            Cancelled: "Cancelled";
+            MinDelayChange: "MinDelayChange";
+            QueueTransaction: "QueueTransaction";
+            ExecuteTransaction: "ExecuteTransaction";
+            CancelTransaction: "CancelTransaction";
+            NewDelay: "NewDelay";
+            NewAdmin: "NewAdmin";
+            NewPendingAdmin: "NewPendingAdmin";
+        }>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"control-change">;
+        contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            RoleGranted: "RoleGranted";
+            RoleRevoked: "RoleRevoked";
+            RoleAdminChanged: "RoleAdminChanged";
+            Paused: "Paused";
+            Unpaused: "Unpaused";
+        }>>>;
+    }, z.core.$strict>], "type">, unknown>>;
+    maximumLogs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type WatchtowerWindowInput = z.infer<typeof WatchtowerWindowInputSchema>;
+/** Worst-case RPC reads for one window: identity, latest head, from/to headers, one eth_getLogs per rule, a covered-through header and the final recheck. */
+export declare const watchWindowRpcEstimate: (rules: number) => number;
+export declare const WATCHTOWER_MANIFEST: {
+    schemaVersion: "1.0";
+    id: string;
+    version: string;
+    name: string;
+    description: string;
+    author: {
+        id: string;
+        name: string;
+        ownership: "first-party" | "independent";
+    };
+    license: string;
+    visibility: "private" | "source-visible" | "source-private";
+    chains: ("ethereum" | "base" | "robinhood")[];
+    inputSchema: {
+        type: "object";
+        properties: Record<string, {
+            type: "string" | "number" | "boolean" | "array" | "integer";
+            description: string;
+            enum?: (string | number | boolean)[] | undefined;
+        }>;
+        required: string[];
+        additionalProperties: false;
+    };
+    outputSchemaId: "agentex.token-research.v1" | "agentex.transaction-inspection.v1" | "agentex.watchtower-window.v1";
+    tools: {
+        id: string;
+        version: string;
+        capability: "evm.read";
+        chains: ("ethereum" | "base" | "robinhood")[];
+        addressScope: "input-address" | "input-transaction" | "input-watch-scope";
+        maximumCalls: number;
+    }[];
+    modelPolicy: {
+        mode: "deterministic";
+        maximumModelTokens: 0;
+    };
+    limits: {
+        maximumRpcCalls: number;
+        maximumDurationMs: number;
+        maximumOutputBytes: number;
+        maximumGraphDepth: number;
+        maximumPages: 0;
+        maximumExecutionAtomic: string;
+    };
+    workflow: ({
+        type: "input";
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "tool";
+        tool: string;
+        arguments: Record<string, {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        }>;
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "condition";
+        field: {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        };
+        operator: "equals" | "exists";
+        whenTrue: string;
+        whenFalse: string;
+        id: string;
+        dependsOn: string[];
+        value?: string | number | boolean | undefined;
+    } | {
+        type: "output";
+        from: string;
+        id: string;
+        dependsOn: string[];
+    })[];
+    testCases: string[];
+    researchPolicy?: {
+        readOwner: boolean;
+        readProxySlots: boolean;
+    } | undefined;
+    policy?: {
+        analysis: {
+            mode: "summary";
+            maximumOutputTokens: number;
+            maximumCostMicrousd: number;
+        };
+    } | undefined;
+    marketPolicy?: {
+        discoverPools: boolean;
+        recentHolderActivity: boolean;
+    } | undefined;
+};
+/** Watchtower 0.2.0: identical graph, tool, limits and output schema to 0.1.0 (kept byte-identical, hash f5ad5883…); instant-read wording for new drafts. */
+export declare const WATCHTOWER_MANIFEST_V2: {
+    schemaVersion: "1.0";
+    id: string;
+    version: string;
+    name: string;
+    description: string;
+    author: {
+        id: string;
+        name: string;
+        ownership: "first-party" | "independent";
+    };
+    license: string;
+    visibility: "private" | "source-visible" | "source-private";
+    chains: ("ethereum" | "base" | "robinhood")[];
+    inputSchema: {
+        type: "object";
+        properties: Record<string, {
+            type: "string" | "number" | "boolean" | "array" | "integer";
+            description: string;
+            enum?: (string | number | boolean)[] | undefined;
+        }>;
+        required: string[];
+        additionalProperties: false;
+    };
+    outputSchemaId: "agentex.token-research.v1" | "agentex.transaction-inspection.v1" | "agentex.watchtower-window.v1";
+    tools: {
+        id: string;
+        version: string;
+        capability: "evm.read";
+        chains: ("ethereum" | "base" | "robinhood")[];
+        addressScope: "input-address" | "input-transaction" | "input-watch-scope";
+        maximumCalls: number;
+    }[];
+    modelPolicy: {
+        mode: "deterministic";
+        maximumModelTokens: 0;
+    };
+    limits: {
+        maximumRpcCalls: number;
+        maximumDurationMs: number;
+        maximumOutputBytes: number;
+        maximumGraphDepth: number;
+        maximumPages: 0;
+        maximumExecutionAtomic: string;
+    };
+    workflow: ({
+        type: "input";
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "tool";
+        tool: string;
+        arguments: Record<string, {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        }>;
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "condition";
+        field: {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        };
+        operator: "equals" | "exists";
+        whenTrue: string;
+        whenFalse: string;
+        id: string;
+        dependsOn: string[];
+        value?: string | number | boolean | undefined;
+    } | {
+        type: "output";
+        from: string;
+        id: string;
+        dependsOn: string[];
+    })[];
+    testCases: string[];
+    researchPolicy?: {
+        readOwner: boolean;
+        readProxySlots: boolean;
+    } | undefined;
+    policy?: {
+        analysis: {
+            mode: "summary";
+            maximumOutputTokens: number;
+            maximumCostMicrousd: number;
+        };
+    } | undefined;
+    marketPolicy?: {
+        discoverPools: boolean;
+        recentHolderActivity: boolean;
+    } | undefined;
+};
+/**
+ * Watchtower 0.3.0: the same bounded window graph, tool and output schema, plus wallet token flows across a token list, pool swaps and
+ * liquidity changes, governance and timelock events and access-control or pause events, and Robinhood Chain. New drafts start from it.
+ */
+export declare const WATCHTOWER_MANIFEST_V3: {
+    schemaVersion: "1.0";
+    id: string;
+    version: string;
+    name: string;
+    description: string;
+    author: {
+        id: string;
+        name: string;
+        ownership: "first-party" | "independent";
+    };
+    license: string;
+    visibility: "private" | "source-visible" | "source-private";
+    chains: ("ethereum" | "base" | "robinhood")[];
+    inputSchema: {
+        type: "object";
+        properties: Record<string, {
+            type: "string" | "number" | "boolean" | "array" | "integer";
+            description: string;
+            enum?: (string | number | boolean)[] | undefined;
+        }>;
+        required: string[];
+        additionalProperties: false;
+    };
+    outputSchemaId: "agentex.token-research.v1" | "agentex.transaction-inspection.v1" | "agentex.watchtower-window.v1";
+    tools: {
+        id: string;
+        version: string;
+        capability: "evm.read";
+        chains: ("ethereum" | "base" | "robinhood")[];
+        addressScope: "input-address" | "input-transaction" | "input-watch-scope";
+        maximumCalls: number;
+    }[];
+    modelPolicy: {
+        mode: "deterministic";
+        maximumModelTokens: 0;
+    };
+    limits: {
+        maximumRpcCalls: number;
+        maximumDurationMs: number;
+        maximumOutputBytes: number;
+        maximumGraphDepth: number;
+        maximumPages: 0;
+        maximumExecutionAtomic: string;
+    };
+    workflow: ({
+        type: "input";
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "tool";
+        tool: string;
+        arguments: Record<string, {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        }>;
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "condition";
+        field: {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        };
+        operator: "equals" | "exists";
+        whenTrue: string;
+        whenFalse: string;
+        id: string;
+        dependsOn: string[];
+        value?: string | number | boolean | undefined;
+    } | {
+        type: "output";
+        from: string;
+        id: string;
+        dependsOn: string[];
+    })[];
+    testCases: string[];
+    researchPolicy?: {
+        readOwner: boolean;
+        readProxySlots: boolean;
+    } | undefined;
+    policy?: {
+        analysis: {
+            mode: "summary";
+            maximumOutputTokens: number;
+            maximumCostMicrousd: number;
+        };
+    } | undefined;
+    marketPolicy?: {
+        discoverPools: boolean;
+        recentHolderActivity: boolean;
+    } | undefined;
+};
+/** The rule types an exact Watchtower version declares. Returns the refusal for the first rule its version cannot run, or null. */
+export declare function watchRuleRefusal(version: string, rules: readonly {
+    id: string;
+    type: string;
+}[]): string | null;
+export declare const SupportedWatchtowerManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    id: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    author: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        ownership: z.ZodEnum<{
+            "first-party": "first-party";
+            independent: "independent";
+        }>;
+    }, z.core.$strict>;
+    license: z.ZodString;
+    visibility: z.ZodEnum<{
+        private: "private";
+        "source-visible": "source-visible";
+        "source-private": "source-private";
+    }>;
+    chains: z.ZodArray<z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+    }>>;
+    inputSchema: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                array: "array";
+                integer: "integer";
+            }>;
+            description: z.ZodString;
+            enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        }, z.core.$strict>>;
+        required: z.ZodArray<z.ZodString>;
+        additionalProperties: z.ZodLiteral<false>;
+    }, z.core.$strict>;
+    outputSchemaId: z.ZodEnum<{
+        "agentex.token-research.v1": "agentex.token-research.v1";
+        "agentex.transaction-inspection.v1": "agentex.transaction-inspection.v1";
+        "agentex.watchtower-window.v1": "agentex.watchtower-window.v1";
+    }>;
+    tools: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        capability: z.ZodLiteral<"evm.read">;
+        chains: z.ZodArray<z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+            robinhood: "robinhood";
+        }>>;
+        addressScope: z.ZodEnum<{
+            "input-address": "input-address";
+            "input-transaction": "input-transaction";
+            "input-watch-scope": "input-watch-scope";
+        }>;
+        maximumCalls: z.ZodNumber;
+    }, z.core.$strict>>;
+    modelPolicy: z.ZodObject<{
+        mode: z.ZodLiteral<"deterministic">;
+        maximumModelTokens: z.ZodLiteral<0>;
+    }, z.core.$strict>;
+    researchPolicy: z.ZodOptional<z.ZodObject<{
+        readOwner: z.ZodBoolean;
+        readProxySlots: z.ZodBoolean;
+    }, z.core.$strict>>;
+    policy: z.ZodOptional<z.ZodObject<{
+        analysis: z.ZodObject<{
+            mode: z.ZodLiteral<"summary">;
+            maximumOutputTokens: z.ZodNumber;
+            maximumCostMicrousd: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    marketPolicy: z.ZodOptional<z.ZodObject<{
+        discoverPools: z.ZodBoolean;
+        recentHolderActivity: z.ZodBoolean;
+    }, z.core.$strict>>;
+    limits: z.ZodObject<{
+        maximumRpcCalls: z.ZodNumber;
+        maximumDurationMs: z.ZodNumber;
+        maximumOutputBytes: z.ZodNumber;
+        maximumGraphDepth: z.ZodNumber;
+        maximumPages: z.ZodLiteral<0>;
+        maximumExecutionAtomic: z.ZodString;
+    }, z.core.$strict>;
+    workflow: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"input">;
+        id: z.ZodString;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tool">;
+        tool: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>], "source">>;
+        id: z.ZodString;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"condition">;
+        field: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>], "source">;
+        operator: z.ZodEnum<{
+            equals: "equals";
+            exists: "exists";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>;
+        whenTrue: z.ZodString;
+        whenFalse: z.ZodString;
+        id: z.ZodString;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"output">;
+        from: z.ZodString;
+        id: z.ZodString;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "type">>;
+    testCases: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const WatchEvidenceItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    tool: z.ZodLiteral<"evm.watch-logs@0.1.0">;
+    source: z.ZodObject<{
+        kind: z.ZodLiteral<"rpc">;
+        provider: z.ZodString;
+        method: z.ZodString;
+        documentationUrl: z.ZodURL;
+    }, z.core.$strict>;
+    chain: z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+    }>;
+    chainId: z.ZodNumber;
+    request: z.ZodArray<z.ZodJSONSchema>;
+    snapshot: z.ZodNullable<z.ZodObject<{
+        blockNumber: z.ZodString;
+        blockHash: z.ZodString;
+    }, z.core.$strict>>;
+    observedAt: z.ZodISODateTime;
+    finality: z.ZodEnum<{
+        finalized: "finalized";
+        "sequencer-confirmed": "sequencer-confirmed";
+        unverified: "unverified";
+    }>;
+    canonicality: z.ZodEnum<{
+        "verified-at-completion": "verified-at-completion";
+        unchecked: "unchecked";
+        changed: "changed";
+    }>;
+    completeness: z.ZodEnum<{
+        error: "error";
+        "complete-for-request": "complete-for-request";
+    }>;
+    result: z.ZodJSONSchema;
+    contentHash: z.ZodString;
+    privacy: z.ZodLiteral<"public-chain-data">;
+}, z.core.$strict>;
+export type WatchEvidenceItem = z.infer<typeof WatchEvidenceItemSchema>;
+export declare const WatchIgnoredReasonSchema: z.ZodEnum<{
+    "address-mismatch": "address-mismatch";
+    "topic-mismatch": "topic-mismatch";
+    "data-mismatch": "data-mismatch";
+    "filter-mismatch": "filter-mismatch";
+    "below-minimum": "below-minimum";
+    removed: "removed";
+    "outside-coverage": "outside-coverage";
+}>;
+export type WatchIgnoredReason = z.infer<typeof WatchIgnoredReasonSchema>;
+export declare const WatchEventSchema: z.ZodObject<{
+    eventKey: z.ZodString;
+    ruleId: z.ZodString;
+    ruleType: z.ZodEnum<{
+        "authority-change": "authority-change";
+        "wallet-token-flow": "wallet-token-flow";
+        "pool-activity": "pool-activity";
+        "governance-change": "governance-change";
+        "control-change": "control-change";
+        "erc20-transfer": "erc20-transfer";
+        "erc20-approval": "erc20-approval";
+    }>;
+    event: z.ZodEnum<{
+        Upgraded: "Upgraded";
+        AdminChanged: "AdminChanged";
+        BeaconUpgraded: "BeaconUpgraded";
+        OwnershipTransferred: "OwnershipTransferred";
+        ProposalCreated: "ProposalCreated";
+        ProposalQueued: "ProposalQueued";
+        ProposalExecuted: "ProposalExecuted";
+        ProposalCanceled: "ProposalCanceled";
+        CallScheduled: "CallScheduled";
+        CallExecuted: "CallExecuted";
+        Cancelled: "Cancelled";
+        MinDelayChange: "MinDelayChange";
+        QueueTransaction: "QueueTransaction";
+        ExecuteTransaction: "ExecuteTransaction";
+        CancelTransaction: "CancelTransaction";
+        NewDelay: "NewDelay";
+        NewAdmin: "NewAdmin";
+        NewPendingAdmin: "NewPendingAdmin";
+        RoleGranted: "RoleGranted";
+        RoleRevoked: "RoleRevoked";
+        RoleAdminChanged: "RoleAdminChanged";
+        Paused: "Paused";
+        Unpaused: "Unpaused";
+        Swap: "Swap";
+        Mint: "Mint";
+        Burn: "Burn";
+        Transfer: "Transfer";
+        Approval: "Approval";
+    }>;
+    blockNumber: z.ZodString;
+    blockHash: z.ZodString;
+    transactionHash: z.ZodString;
+    logIndex: z.ZodNumber;
+    address: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    fields: z.ZodRecord<z.ZodString, z.ZodString>;
+    explanation: z.ZodString;
+    evidenceIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type WatchEvent = z.infer<typeof WatchEventSchema>;
+export declare const WatchRuleCoverageSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        "authority-change": "authority-change";
+        "wallet-token-flow": "wallet-token-flow";
+        "pool-activity": "pool-activity";
+        "governance-change": "governance-change";
+        "control-change": "control-change";
+        "erc20-transfer": "erc20-transfer";
+        "erc20-approval": "erc20-approval";
+    }>;
+    coverage: z.ZodEnum<{
+        unavailable: "unavailable";
+        "not-read": "not-read";
+        truncated: "truncated";
+        complete: "complete";
+    }>;
+    logsReturned: z.ZodNumber;
+    logsMatched: z.ZodNumber;
+    ignored: z.ZodRecord<z.ZodEnum<{
+        "address-mismatch": "address-mismatch";
+        "topic-mismatch": "topic-mismatch";
+        "data-mismatch": "data-mismatch";
+        "filter-mismatch": "filter-mismatch";
+        "below-minimum": "below-minimum";
+        removed: "removed";
+        "outside-coverage": "outside-coverage";
+    }> & z.core.$partial, z.ZodNumber>;
+    coveredThroughBlock: z.ZodNullable<z.ZodString>;
+    reason: z.ZodString;
+    evidenceIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const WatchtowerWindowReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"agentex.watchtower-window.v1">;
+    agentVersion: z.ZodString;
+    manifestHash: z.ZodString;
+    input: z.ZodObject<{
+        chain: z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+            robinhood: "robinhood";
+        }>;
+        fromBlock: z.ZodString;
+        toBlock: z.ZodString;
+        rules: z.ZodArray<z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"erc20-transfer">;
+            token: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+            from: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+            to: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+            minimumAtomic: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"erc20-approval">;
+            token: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+            owner: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+            spender: z.ZodOptional<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"authority-change">;
+            contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+            events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                Upgraded: "Upgraded";
+                AdminChanged: "AdminChanged";
+                BeaconUpgraded: "BeaconUpgraded";
+                OwnershipTransferred: "OwnershipTransferred";
+            }>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"wallet-token-flow">;
+            wallet: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+            tokens: z.ZodArray<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+            direction: z.ZodEnum<{
+                out: "out";
+                in: "in";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"pool-activity">;
+            pool: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+            dex: z.ZodEnum<{
+                "uniswap-v2": "uniswap-v2";
+                "uniswap-v3": "uniswap-v3";
+                aerodrome: "aerodrome";
+            }>;
+            events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                Swap: "Swap";
+                Mint: "Mint";
+                Burn: "Burn";
+            }>>>;
+            minimumAmount0Atomic: z.ZodOptional<z.ZodString>;
+            minimumAmount1Atomic: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"governance-change">;
+            contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+            events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                ProposalCreated: "ProposalCreated";
+                ProposalQueued: "ProposalQueued";
+                ProposalExecuted: "ProposalExecuted";
+                ProposalCanceled: "ProposalCanceled";
+                CallScheduled: "CallScheduled";
+                CallExecuted: "CallExecuted";
+                Cancelled: "Cancelled";
+                MinDelayChange: "MinDelayChange";
+                QueueTransaction: "QueueTransaction";
+                ExecuteTransaction: "ExecuteTransaction";
+                CancelTransaction: "CancelTransaction";
+                NewDelay: "NewDelay";
+                NewAdmin: "NewAdmin";
+                NewPendingAdmin: "NewPendingAdmin";
+            }>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"control-change">;
+            contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+            events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                RoleGranted: "RoleGranted";
+                RoleRevoked: "RoleRevoked";
+                RoleAdminChanged: "RoleAdminChanged";
+                Paused: "Paused";
+                Unpaused: "Unpaused";
+            }>>>;
+        }, z.core.$strict>], "type">, unknown>>;
+        maximumLogs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+        failed: "failed";
+    }>;
+    generatedAt: z.ZodISODateTime;
+    chainId: z.ZodNullable<z.ZodNumber>;
+    window: z.ZodObject<{
+        fromBlock: z.ZodString;
+        toBlock: z.ZodString;
+        fromBlockHash: z.ZodNullable<z.ZodString>;
+        toBlockHash: z.ZodNullable<z.ZodString>;
+        toBlockTimestamp: z.ZodNullable<z.ZodString>;
+        finality: z.ZodEnum<{
+            finalized: "finalized";
+            "sequencer-confirmed": "sequencer-confirmed";
+        }>;
+        canonicality: z.ZodEnum<{
+            "verified-at-completion": "verified-at-completion";
+            unchecked: "unchecked";
+            changed: "changed";
+        }>;
+        coverage: z.ZodEnum<{
+            unavailable: "unavailable";
+            complete: "complete";
+            partial: "partial";
+        }>;
+        coveredThroughBlock: z.ZodNullable<z.ZodString>;
+        coveredThroughBlockHash: z.ZodNullable<z.ZodString>;
+        finalizedBlock: z.ZodNullable<z.ZodString>;
+        finalityLagBlocks: z.ZodNullable<z.ZodNumber>;
+        dataLagSeconds: z.ZodNullable<z.ZodNumber>;
+        headBlock: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        headLagBlocks: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strict>;
+    rules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            "authority-change": "authority-change";
+            "wallet-token-flow": "wallet-token-flow";
+            "pool-activity": "pool-activity";
+            "governance-change": "governance-change";
+            "control-change": "control-change";
+            "erc20-transfer": "erc20-transfer";
+            "erc20-approval": "erc20-approval";
+        }>;
+        coverage: z.ZodEnum<{
+            unavailable: "unavailable";
+            "not-read": "not-read";
+            truncated: "truncated";
+            complete: "complete";
+        }>;
+        logsReturned: z.ZodNumber;
+        logsMatched: z.ZodNumber;
+        ignored: z.ZodRecord<z.ZodEnum<{
+            "address-mismatch": "address-mismatch";
+            "topic-mismatch": "topic-mismatch";
+            "data-mismatch": "data-mismatch";
+            "filter-mismatch": "filter-mismatch";
+            "below-minimum": "below-minimum";
+            removed: "removed";
+            "outside-coverage": "outside-coverage";
+        }> & z.core.$partial, z.ZodNumber>;
+        coveredThroughBlock: z.ZodNullable<z.ZodString>;
+        reason: z.ZodString;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    events: z.ZodArray<z.ZodObject<{
+        eventKey: z.ZodString;
+        ruleId: z.ZodString;
+        ruleType: z.ZodEnum<{
+            "authority-change": "authority-change";
+            "wallet-token-flow": "wallet-token-flow";
+            "pool-activity": "pool-activity";
+            "governance-change": "governance-change";
+            "control-change": "control-change";
+            "erc20-transfer": "erc20-transfer";
+            "erc20-approval": "erc20-approval";
+        }>;
+        event: z.ZodEnum<{
+            Upgraded: "Upgraded";
+            AdminChanged: "AdminChanged";
+            BeaconUpgraded: "BeaconUpgraded";
+            OwnershipTransferred: "OwnershipTransferred";
+            ProposalCreated: "ProposalCreated";
+            ProposalQueued: "ProposalQueued";
+            ProposalExecuted: "ProposalExecuted";
+            ProposalCanceled: "ProposalCanceled";
+            CallScheduled: "CallScheduled";
+            CallExecuted: "CallExecuted";
+            Cancelled: "Cancelled";
+            MinDelayChange: "MinDelayChange";
+            QueueTransaction: "QueueTransaction";
+            ExecuteTransaction: "ExecuteTransaction";
+            CancelTransaction: "CancelTransaction";
+            NewDelay: "NewDelay";
+            NewAdmin: "NewAdmin";
+            NewPendingAdmin: "NewPendingAdmin";
+            RoleGranted: "RoleGranted";
+            RoleRevoked: "RoleRevoked";
+            RoleAdminChanged: "RoleAdminChanged";
+            Paused: "Paused";
+            Unpaused: "Unpaused";
+            Swap: "Swap";
+            Mint: "Mint";
+            Burn: "Burn";
+            Transfer: "Transfer";
+            Approval: "Approval";
+        }>;
+        blockNumber: z.ZodString;
+        blockHash: z.ZodString;
+        transactionHash: z.ZodString;
+        logIndex: z.ZodNumber;
+        address: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        fields: z.ZodRecord<z.ZodString, z.ZodString>;
+        explanation: z.ZodString;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    unknowns: z.ZodArray<z.ZodString>;
+    limitations: z.ZodArray<z.ZodString>;
+    errors: z.ZodArray<z.ZodObject<{
+        category: z.ZodEnum<{
+            "no-contract": "no-contract";
+            "provider-unavailable": "provider-unavailable";
+            "history-unavailable": "history-unavailable";
+            "rate-limited": "rate-limited";
+            timeout: "timeout";
+            cancelled: "cancelled";
+            unsupported: "unsupported";
+            "contract-reverted": "contract-reverted";
+            "invalid-response": "invalid-response";
+            "chain-mismatch": "chain-mismatch";
+            "snapshot-changed": "snapshot-changed";
+            "limit-exceeded": "limit-exceeded";
+            unconfigured: "unconfigured";
+        }>;
+        message: z.ZodString;
+        step: z.ZodString;
+        evidenceId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tool: z.ZodLiteral<"evm.watch-logs@0.1.0">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"rpc">;
+            provider: z.ZodString;
+            method: z.ZodString;
+            documentationUrl: z.ZodURL;
+        }, z.core.$strict>;
+        chain: z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+            robinhood: "robinhood";
+        }>;
+        chainId: z.ZodNumber;
+        request: z.ZodArray<z.ZodJSONSchema>;
+        snapshot: z.ZodNullable<z.ZodObject<{
+            blockNumber: z.ZodString;
+            blockHash: z.ZodString;
+        }, z.core.$strict>>;
+        observedAt: z.ZodISODateTime;
+        finality: z.ZodEnum<{
+            finalized: "finalized";
+            "sequencer-confirmed": "sequencer-confirmed";
+            unverified: "unverified";
+        }>;
+        canonicality: z.ZodEnum<{
+            "verified-at-completion": "verified-at-completion";
+            unchecked: "unchecked";
+            changed: "changed";
+        }>;
+        completeness: z.ZodEnum<{
+            error: "error";
+            "complete-for-request": "complete-for-request";
+        }>;
+        result: z.ZodJSONSchema;
+        contentHash: z.ZodString;
+        privacy: z.ZodLiteral<"public-chain-data">;
+    }, z.core.$strict>>;
+    usage: z.ZodObject<{
+        rpcCalls: z.ZodNumber;
+        maximumRpcCalls: z.ZodNumber;
+        elapsedMs: z.ZodNumber;
+        modelTokens: z.ZodLiteral<0>;
+        providerCostAtomic: z.ZodNull;
+        providerCostStatus: z.ZodLiteral<"unpriced">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type WatchtowerWindowReport = z.infer<typeof WatchtowerWindowReportSchema>;