agentex-creator-sdk 1.0.0

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

@@ -0,0 +1,906 @@
+import { z } from 'zod';
+/** Transaction Inspector contracts. Kept outside index.ts so both modules initialise without a circular import. */
+export declare const INSPECTION_MAX_DATA_BYTES = 16384;
+export declare const INSPECTION_RPC_CEILING = 24;
+export declare const INSPECTION_TOOL: "evm.inspect-transaction@0.1.0";
+export declare const CalldataSchema: z.ZodString;
+/** A proposed, unsigned payload. There is deliberately no signature, nonce, key or broadcast field. */
+export declare const TransactionInspectionInputSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+    }>;
+    from: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    to: z.ZodDefault<z.ZodNullable<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>>;
+    data: z.ZodString;
+    value: z.ZodDefault<z.ZodString>;
+    snapshotBlock: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TransactionInspectionInput = z.infer<typeof TransactionInspectionInputSchema>;
+export declare const TRANSACTION_INSPECTOR_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;
+};
+/** Transaction Inspector 0.2.0: identical graph, tool, limits and output schema to 0.1.0 (kept byte-identical, hash 4dab080b…); instant-read wording for new drafts. */
+export declare const TRANSACTION_INSPECTOR_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;
+};
+/** Executable manifest subset for the transaction inspector: fixed graph and tool, selectable chains and lower limits only. */
+export declare const SupportedTransactionInspectorManifestSchema: 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 InspectionEvidenceItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    tool: z.ZodLiteral<"evm.inspect-transaction@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 InspectionEvidenceItem = z.infer<typeof InspectionEvidenceItemSchema>;
+export declare const INSPECTION_RPC_METHODS: readonly ["eth_chainId", "eth_getBlockByNumber", "eth_getCode", "eth_getStorageAt", "eth_call", "eth_estimateGas"];
+export declare const DecodedActionKindSchema: z.ZodEnum<{
+    unknown: "unknown";
+    "contract-creation": "contract-creation";
+    "native-transfer": "native-transfer";
+    "erc20.transfer": "erc20.transfer";
+    "erc20.approve": "erc20.approve";
+    "erc20-or-erc721.transferFrom": "erc20-or-erc721.transferFrom";
+    "erc20.increaseAllowance": "erc20.increaseAllowance";
+    "erc20.decreaseAllowance": "erc20.decreaseAllowance";
+    "eip2612.permit": "eip2612.permit";
+    "erc721-or-erc1155.setApprovalForAll": "erc721-or-erc1155.setApprovalForAll";
+    "erc721.safeTransferFrom": "erc721.safeTransferFrom";
+    "erc1155.safeTransferFrom": "erc1155.safeTransferFrom";
+    "weth.deposit": "weth.deposit";
+    "weth.withdraw": "weth.withdraw";
+    multicall: "multicall";
+}>;
+export type DecodedActionKind = z.infer<typeof DecodedActionKindSchema>;
+export declare const DecodedActionSchema: z.ZodObject<{
+    path: z.ZodString;
+    depth: z.ZodNumber;
+    target: z.ZodNullable<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        decoded: "decoded";
+        invalid: "invalid";
+        "bound-reached": "bound-reached";
+    }>;
+    kind: z.ZodEnum<{
+        unknown: "unknown";
+        "contract-creation": "contract-creation";
+        "native-transfer": "native-transfer";
+        "erc20.transfer": "erc20.transfer";
+        "erc20.approve": "erc20.approve";
+        "erc20-or-erc721.transferFrom": "erc20-or-erc721.transferFrom";
+        "erc20.increaseAllowance": "erc20.increaseAllowance";
+        "erc20.decreaseAllowance": "erc20.decreaseAllowance";
+        "eip2612.permit": "eip2612.permit";
+        "erc721-or-erc1155.setApprovalForAll": "erc721-or-erc1155.setApprovalForAll";
+        "erc721.safeTransferFrom": "erc721.safeTransferFrom";
+        "erc1155.safeTransferFrom": "erc1155.safeTransferFrom";
+        "weth.deposit": "weth.deposit";
+        "weth.withdraw": "weth.withdraw";
+        multicall: "multicall";
+    }>;
+    selector: z.ZodNullable<z.ZodString>;
+    signature: z.ZodNullable<z.ZodString>;
+    arguments: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
+    notes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type DecodedAction = z.infer<typeof DecodedActionSchema>;
+export declare const InspectionFindingCodeSchema: z.ZodEnum<{
+    "contract-creation": "contract-creation";
+    "unlimited-approval": "unlimited-approval";
+    "approval-grantee-without-code": "approval-grantee-without-code";
+    "operator-approval-granted": "operator-approval-granted";
+    "operator-grantee-without-code": "operator-grantee-without-code";
+    "native-value-sent": "native-value-sent";
+    "upgradeable-proxy-target": "upgradeable-proxy-target";
+    "target-without-code": "target-without-code";
+    "simulation-reverted": "simulation-reverted";
+    "unknown-action": "unknown-action";
+    "invalid-calldata": "invalid-calldata";
+    "decoding-bound-reached": "decoding-bound-reached";
+}>;
+export type InspectionFindingCode = z.infer<typeof InspectionFindingCodeSchema>;
+export declare const TransactionInspectionReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"agentex.transaction-inspection.v1">;
+    agentVersion: z.ZodString;
+    manifestHash: z.ZodString;
+    input: z.ZodObject<{
+        chain: z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+            robinhood: "robinhood";
+        }>;
+        from: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        to: z.ZodDefault<z.ZodNullable<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>>;
+        data: z.ZodString;
+        value: z.ZodDefault<z.ZodString>;
+        snapshotBlock: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+        failed: "failed";
+    }>;
+    generatedAt: z.ZodISODateTime;
+    chainId: z.ZodNullable<z.ZodNumber>;
+    snapshot: z.ZodNullable<z.ZodObject<{
+        blockNumber: z.ZodString;
+        blockHash: z.ZodString;
+        timestamp: z.ZodString;
+        finality: z.ZodEnum<{
+            finalized: "finalized";
+            "sequencer-confirmed": "sequencer-confirmed";
+        }>;
+        canonicality: z.ZodEnum<{
+            "verified-at-completion": "verified-at-completion";
+            unchecked: "unchecked";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>>;
+    transaction: z.ZodObject<{
+        kind: z.ZodEnum<{
+            "contract-creation": "contract-creation";
+            "native-transfer": "native-transfer";
+            call: "call";
+        }>;
+        selector: z.ZodNullable<z.ZodString>;
+        dataBytes: z.ZodNumber;
+        dataHash: z.ZodString;
+        valueAtomic: z.ZodString;
+        valueFormatted: z.ZodString;
+        valueUnit: z.ZodLiteral<"native-18-decimals">;
+    }, z.core.$strict>;
+    actions: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        depth: z.ZodNumber;
+        target: z.ZodNullable<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            decoded: "decoded";
+            invalid: "invalid";
+            "bound-reached": "bound-reached";
+        }>;
+        kind: z.ZodEnum<{
+            unknown: "unknown";
+            "contract-creation": "contract-creation";
+            "native-transfer": "native-transfer";
+            "erc20.transfer": "erc20.transfer";
+            "erc20.approve": "erc20.approve";
+            "erc20-or-erc721.transferFrom": "erc20-or-erc721.transferFrom";
+            "erc20.increaseAllowance": "erc20.increaseAllowance";
+            "erc20.decreaseAllowance": "erc20.decreaseAllowance";
+            "eip2612.permit": "eip2612.permit";
+            "erc721-or-erc1155.setApprovalForAll": "erc721-or-erc1155.setApprovalForAll";
+            "erc721.safeTransferFrom": "erc721.safeTransferFrom";
+            "erc1155.safeTransferFrom": "erc1155.safeTransferFrom";
+            "weth.deposit": "weth.deposit";
+            "weth.withdraw": "weth.withdraw";
+            multicall: "multicall";
+        }>;
+        selector: z.ZodNullable<z.ZodString>;
+        signature: z.ZodNullable<z.ZodString>;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
+        notes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    target: z.ZodObject<{
+        address: z.ZodNullable<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+        codePresent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        codeHash: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        implementation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        admin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        beacon: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        tokenName: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        tokenSymbol: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        tokenDecimals: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>;
+    grantees: z.ZodArray<z.ZodObject<{
+        address: 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>>;
+        role: z.ZodEnum<{
+            operator: "operator";
+            spender: "spender";
+        }>;
+        actionPaths: z.ZodArray<z.ZodString>;
+        codePresent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        currentAllowance: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>>;
+    simulation: z.ZodObject<{
+        semantics: z.ZodLiteral<"eth_call-at-snapshot-not-asset-flow">;
+        call: z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                success: "success";
+                "not-run": "not-run";
+                reverted: "reverted";
+                "execution-error": "execution-error";
+            }>;
+            reason: z.ZodString;
+            returnData: z.ZodNullable<z.ZodString>;
+            returnDataBytes: z.ZodNullable<z.ZodNumber>;
+            returnDataHash: z.ZodNullable<z.ZodString>;
+            revertData: z.ZodNullable<z.ZodString>;
+            revertReason: z.ZodNullable<z.ZodString>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        gasEstimate: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        balanceChanges: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>;
+    findings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            "contract-creation": "contract-creation";
+            "unlimited-approval": "unlimited-approval";
+            "approval-grantee-without-code": "approval-grantee-without-code";
+            "operator-approval-granted": "operator-approval-granted";
+            "operator-grantee-without-code": "operator-grantee-without-code";
+            "native-value-sent": "native-value-sent";
+            "upgradeable-proxy-target": "upgradeable-proxy-target";
+            "target-without-code": "target-without-code";
+            "simulation-reverted": "simulation-reverted";
+            "unknown-action": "unknown-action";
+            "invalid-calldata": "invalid-calldata";
+            "decoding-bound-reached": "decoding-bound-reached";
+        }>;
+        message: z.ZodString;
+        actionPaths: z.ZodArray<z.ZodString>;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    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.inspect-transaction@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 TransactionInspectionReport = z.infer<typeof TransactionInspectionReportSchema>;