agentex-creator-sdk 1.0.0

package/dist/packages/contracts/src/deployer-investigation.d.ts

@@ -0,0 +1,1015 @@
+import { z } from 'zod';
+/**
+ * P02 Deployer Investigator contract. Input: an explicit chain and contract, an optional creation transaction (verified, never trusted) and
+ * bounds for the funding and related-deployment sections. Output: how the contract was created, the observed sender/factory roles, the
+ * sender's earliest indexed funding, its other top-level creations, a chronological timeline and an evidence-linked relationship graph.
+ * Roles never identify people; a funding link or a shared sender is an observed relationship, not proof of common ownership or intent.
+ */
+export declare const DEPLOYER_SCHEMA_ID: "agentex.deployer-investigation.v1";
+export declare const DEPLOYER_TOOLS: readonly ("evm.contract-origin@0.1.0" | "evm.address-funding@0.1.0" | "evm.deployer-launches@0.1.0")[];
+/** Pin (2) + code + one anchor + receipt + recheck: the least budget that can confirm a creation. */
+export declare const DEPLOYER_MINIMUM_RPC_CALLS = 6;
+export declare const DeployerInvestigationInputSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+    }>;
+    contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    creationTransaction: z.ZodOptional<z.ZodString>;
+    maximumFundingTransfers: z.ZodDefault<z.ZodNumber>;
+    maximumRelatedTransactions: z.ZodDefault<z.ZodNumber>;
+    maximumRelatedReceipts: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type DeployerInvestigationInput = z.infer<typeof DeployerInvestigationInputSchema>;
+declare const ManifestSchema: 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";
+    }>>;
+    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.ZodLiteral<"agentex.deployer-investigation.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";
+        }>>;
+        addressScope: z.ZodLiteral<"input-address">;
+        maximumCalls: z.ZodNumber;
+    }, z.core.$strict>>;
+    modelPolicy: z.ZodObject<{
+        mode: z.ZodLiteral<"deterministic">;
+        maximumModelTokens: z.ZodLiteral<0>;
+    }, 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>>;
+    limits: z.ZodObject<{
+        maximumRpcCalls: z.ZodNumber;
+        maximumDurationMs: z.ZodNumber;
+        maximumOutputBytes: z.ZodNumber;
+        maximumGraphDepth: z.ZodNumber;
+        maximumPages: z.ZodNumber;
+        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 DEPLOYER_INVESTIGATOR_MANIFEST: Readonly<{
+    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")[];
+    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.deployer-investigation.v1";
+    tools: {
+        id: string;
+        version: string;
+        capability: "evm.read";
+        chains: ("ethereum" | "base")[];
+        addressScope: "input-address";
+        maximumCalls: number;
+    }[];
+    modelPolicy: {
+        mode: "deterministic";
+        maximumModelTokens: 0;
+    };
+    limits: {
+        maximumRpcCalls: number;
+        maximumDurationMs: number;
+        maximumOutputBytes: number;
+        maximumGraphDepth: number;
+        maximumPages: number;
+        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[];
+    policy?: {
+        analysis: {
+            mode: "summary";
+            maximumOutputTokens: number;
+            maximumCostMicrousd: number;
+        };
+    } | undefined;
+}>;
+export declare const SupportedDeployerInvestigatorManifestSchema: 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";
+    }>>;
+    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.ZodLiteral<"agentex.deployer-investigation.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";
+        }>>;
+        addressScope: z.ZodLiteral<"input-address">;
+        maximumCalls: z.ZodNumber;
+    }, z.core.$strict>>;
+    modelPolicy: z.ZodObject<{
+        mode: z.ZodLiteral<"deterministic">;
+        maximumModelTokens: z.ZodLiteral<0>;
+    }, 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>>;
+    limits: z.ZodObject<{
+        maximumRpcCalls: z.ZodNumber;
+        maximumDurationMs: z.ZodNumber;
+        maximumOutputBytes: z.ZodNumber;
+        maximumGraphDepth: z.ZodNumber;
+        maximumPages: z.ZodNumber;
+        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 type DeployerInvestigatorManifest = z.infer<typeof ManifestSchema>;
+export declare const DeployerInvestigationReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"agentex.deployer-investigation.v1">;
+    agentVersion: z.ZodString;
+    manifestHash: z.ZodString;
+    input: z.ZodObject<{
+        chain: z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+        }>;
+        contract: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        creationTransaction: z.ZodOptional<z.ZodString>;
+        maximumFundingTransfers: z.ZodDefault<z.ZodNumber>;
+        maximumRelatedTransactions: z.ZodDefault<z.ZodNumber>;
+        maximumRelatedReceipts: z.ZodDefault<z.ZodNumber>;
+    }, 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.ZodLiteral<"sequencer-confirmed">;
+        canonicality: z.ZodEnum<{
+            "verified-at-completion": "verified-at-completion";
+            unchecked: "unchecked";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>>;
+    origin: z.ZodNullable<z.ZodObject<{
+        chain: z.ZodString;
+        findings: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            basis: z.ZodEnum<{
+                "direct-transaction-evidence": "direct-transaction-evidence";
+                "heuristic-association": "heuristic-association";
+                "provider-index-assertion": "provider-index-assertion";
+            }>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        contract: z.ZodString;
+        codeAtSnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+                unavailable: "unavailable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        creation: z.ZodObject<{
+            status: z.ZodEnum<{
+                unavailable: "unavailable";
+                "confirmed-by-receipt": "confirmed-by-receipt";
+                "block-located": "block-located";
+                "bounded-range": "bounded-range";
+                "not-located": "not-located";
+                "no-code-at-snapshot": "no-code-at-snapshot";
+            }>;
+            blockNumber: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"observed">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                evidenceIds: z.ZodArray<z.ZodString>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodEnum<{
+                    error: "error";
+                    unknown: "unknown";
+                    "not-detected": "not-detected";
+                    "not-applicable": "not-applicable";
+                    unavailable: "unavailable";
+                }>;
+                reason: z.ZodString;
+                evidenceIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>], "status">;
+            transactionHash: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"observed">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                evidenceIds: z.ZodArray<z.ZodString>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodEnum<{
+                    error: "error";
+                    unknown: "unknown";
+                    "not-detected": "not-detected";
+                    "not-applicable": "not-applicable";
+                    unavailable: "unavailable";
+                }>;
+                reason: z.ZodString;
+                evidenceIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>], "status">;
+            transactionBasis: z.ZodEnum<{
+                "receipt-contract-address": "receipt-contract-address";
+                "trace-verified-creation": "trace-verified-creation";
+                "first-indexed-activity-in-creation-block": "first-indexed-activity-in-creation-block";
+                "not-established": "not-established";
+            }>;
+            createdBy: z.ZodEnum<{
+                "not-established": "not-established";
+                "top-level-transaction": "top-level-transaction";
+                "contract-call-in-transaction": "contract-call-in-transaction";
+            }>;
+            anchor: z.ZodObject<{
+                source: z.ZodEnum<{
+                    none: "none";
+                    "supplied-transaction": "supplied-transaction";
+                    "first-indexed-token-transfer": "first-indexed-token-transfer";
+                    "first-indexed-inbound-call": "first-indexed-inbound-call";
+                }>;
+                transactionHash: z.ZodNullable<z.ZodString>;
+                blockNumber: z.ZodNullable<z.ZodString>;
+                evidenceIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            range: z.ZodNullable<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>>;
+            probes: z.ZodNumber;
+            codeBeforeCreation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"observed">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                evidenceIds: z.ZodArray<z.ZodString>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodEnum<{
+                    error: "error";
+                    unknown: "unknown";
+                    "not-detected": "not-detected";
+                    "not-applicable": "not-applicable";
+                    unavailable: "unavailable";
+                }>;
+                reason: z.ZodString;
+                evidenceIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>], "status">;
+            codeAtCreationBlock: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"observed">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                evidenceIds: z.ZodArray<z.ZodString>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodEnum<{
+                    error: "error";
+                    unknown: "unknown";
+                    "not-detected": "not-detected";
+                    "not-applicable": "not-applicable";
+                    unavailable: "unavailable";
+                }>;
+                reason: z.ZodString;
+                evidenceIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>], "status">;
+        }, z.core.$strict>;
+        initiator: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+                unavailable: "unavailable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        entryTarget: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+                unavailable: "unavailable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        factoryEventEmitters: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            label: z.ZodNullable<z.ZodString>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        roles: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            role: z.ZodEnum<{
+                "deployment-transaction-sender": "deployment-transaction-sender";
+                "creation-entry-target": "creation-entry-target";
+                "factory-event-emitter": "factory-event-emitter";
+                "erc4337-entrypoint": "erc4337-entrypoint";
+                "trace-verified-creator": "trace-verified-creator";
+                "creation-candidate": "creation-candidate";
+            }>;
+            isPerson: z.ZodLiteral<false>;
+            label: z.ZodNullable<z.ZodString>;
+            basis: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    funding: z.ZodObject<{
+        status: z.ZodEnum<{
+            observed: "observed";
+            unavailable: "unavailable";
+            "not-read": "not-read";
+        }>;
+        reason: z.ZodString;
+        subject: z.ZodNullable<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+        body: z.ZodNullable<z.ZodObject<{
+            chain: z.ZodString;
+            address: z.ZodString;
+            findings: z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                basis: z.ZodEnum<{
+                    "direct-transaction-evidence": "direct-transaction-evidence";
+                    "heuristic-association": "heuristic-association";
+                    "provider-index-assertion": "provider-index-assertion";
+                }>;
+                evidenceIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            coverage: z.ZodObject<{
+                order: z.ZodLiteral<"oldest-first">;
+                categories: z.ZodArray<z.ZodEnum<{
+                    external: "external";
+                    internal: "internal";
+                    erc20: "erc20";
+                    erc721: "erc721";
+                    erc1155: "erc1155";
+                }>>;
+                exhausted: z.ZodBoolean;
+                nextPageKey: z.ZodNullable<z.ZodString>;
+                completeness: z.ZodLiteral<"provider-index-claim">;
+            }, z.core.$strict>;
+            transfers: z.ZodArray<z.ZodObject<{
+                direction: z.ZodEnum<{
+                    out: "out";
+                    in: "in";
+                }>;
+                category: z.ZodEnum<{
+                    external: "external";
+                    internal: "internal";
+                    erc20: "erc20";
+                    erc721: "erc721";
+                    erc1155: "erc1155";
+                }>;
+                blockNumber: z.ZodString;
+                blockTimestamp: z.ZodNullable<z.ZodString>;
+                transactionHash: z.ZodString;
+                uniqueId: z.ZodString;
+                from: z.ZodString;
+                to: z.ZodNullable<z.ZodString>;
+                asset: z.ZodNullable<z.ZodString>;
+                contract: z.ZodNullable<z.ZodString>;
+                tokenId: z.ZodNullable<z.ZodString>;
+                valueAtomic: z.ZodNullable<z.ZodString>;
+                decimals: z.ZodNullable<z.ZodNumber>;
+                valueFormatted: z.ZodNullable<z.ZodString>;
+                decimalsSource: z.ZodEnum<{
+                    "not-applicable": "not-applicable";
+                    "native-18": "native-18";
+                    "provider-raw-contract": "provider-raw-contract";
+                    "not-reported": "not-reported";
+                }>;
+                selfTransfer: z.ZodBoolean;
+                evidenceId: z.ZodString;
+            }, z.core.$strict>>;
+            funders: z.ZodArray<z.ZodObject<{
+                funder: z.ZodString;
+                label: z.ZodNullable<z.ZodString>;
+                isPerson: z.ZodLiteral<false>;
+                transfers: z.ZodNumber;
+                nativeAtomic: z.ZodString;
+                nativeFormatted: z.ZodString;
+                tokenTransfers: z.ZodNumber;
+                firstBlock: z.ZodString;
+                firstTransactionHash: z.ZodString;
+                evidenceIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            pages: z.ZodArray<z.ZodObject<{
+                direction: z.ZodEnum<{
+                    out: "out";
+                    in: "in";
+                }>;
+                index: z.ZodNumber;
+                returned: z.ZodNumber;
+                nextPageKey: z.ZodNullable<z.ZodString>;
+                status: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    "provider-exhausted": "provider-exhausted";
+                    "truncated-with-cursor": "truncated-with-cursor";
+                    "not-read-call-bound": "not-read-call-bound";
+                }>;
+                evidenceId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            interpretation: z.ZodLiteral<"observed-transfer-not-ownership">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    relatedDeployments: z.ZodObject<{
+        status: z.ZodEnum<{
+            observed: "observed";
+            unavailable: "unavailable";
+            "not-read": "not-read";
+        }>;
+        reason: z.ZodString;
+        subject: z.ZodNullable<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>>;
+        body: z.ZodNullable<z.ZodObject<{
+            chain: z.ZodString;
+            findings: z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                basis: z.ZodEnum<{
+                    "direct-transaction-evidence": "direct-transaction-evidence";
+                    "heuristic-association": "heuristic-association";
+                    "provider-index-assertion": "provider-index-assertion";
+                }>;
+                evidenceIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            coverage: z.ZodObject<{
+                transactionsExamined: z.ZodNumber;
+                creationTransactions: z.ZodNumber;
+                receiptsRead: z.ZodNumber;
+                exhausted: z.ZodBoolean;
+                nextPageKey: z.ZodNullable<z.ZodString>;
+                completeness: z.ZodLiteral<"provider-index-claim">;
+            }, z.core.$strict>;
+            window: z.ZodObject<{
+                fromBlock: z.ZodString;
+                toBlock: z.ZodString;
+            }, z.core.$strict>;
+            pages: z.ZodArray<z.ZodObject<{
+                direction: z.ZodEnum<{
+                    out: "out";
+                    in: "in";
+                }>;
+                index: z.ZodNumber;
+                returned: z.ZodNumber;
+                nextPageKey: z.ZodNullable<z.ZodString>;
+                status: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    "provider-exhausted": "provider-exhausted";
+                    "truncated-with-cursor": "truncated-with-cursor";
+                    "not-read-call-bound": "not-read-call-bound";
+                }>;
+                evidenceId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            interpretation: z.ZodLiteral<"same-sender-deployments-not-common-control">;
+            deployer: z.ZodString;
+            deployments: z.ZodArray<z.ZodObject<{
+                transactionHash: z.ZodString;
+                blockNumber: z.ZodString;
+                blockTimestamp: z.ZodNullable<z.ZodString>;
+                contractAddress: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    status: z.ZodLiteral<"observed">;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                    evidenceIds: z.ZodArray<z.ZodString>;
+                    note: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    status: z.ZodEnum<{
+                        error: "error";
+                        unknown: "unknown";
+                        "not-detected": "not-detected";
+                        "not-applicable": "not-applicable";
+                        unavailable: "unavailable";
+                    }>;
+                    reason: z.ZodString;
+                    evidenceIds: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>], "status">;
+                succeeded: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    status: z.ZodLiteral<"observed">;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                    evidenceIds: z.ZodArray<z.ZodString>;
+                    note: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    status: z.ZodEnum<{
+                        error: "error";
+                        unknown: "unknown";
+                        "not-detected": "not-detected";
+                        "not-applicable": "not-applicable";
+                        unavailable: "unavailable";
+                    }>;
+                    reason: z.ZodString;
+                    evidenceIds: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>], "status">;
+                isSubject: z.ZodBoolean;
+                evidenceIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    timeline: z.ZodArray<z.ZodObject<{
+        blockNumber: z.ZodString;
+        transactionHash: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            "contract-creation": "contract-creation";
+            "funding-transfer": "funding-transfer";
+            "related-creation": "related-creation";
+        }>;
+        summary: z.ZodString;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    graph: z.ZodObject<{
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                contract: "contract";
+                account: "account";
+                transaction: "transaction";
+            }>;
+            label: z.ZodNullable<z.ZodString>;
+            isPerson: z.ZodLiteral<false>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            relation: z.ZodEnum<{
+                "sent-creation-transaction": "sent-creation-transaction";
+                "created-contract": "created-contract";
+                "called-in-creation-transaction": "called-in-creation-transaction";
+                "emitted-creation-event": "emitted-creation-event";
+                funded: "funded";
+                "sent-other-creation": "sent-other-creation";
+            }>;
+            basis: z.ZodEnum<{
+                "direct-transaction-evidence": "direct-transaction-evidence";
+                "heuristic-association": "heuristic-association";
+                "provider-index-assertion": "provider-index-assertion";
+            }>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    findings: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        basis: z.ZodEnum<{
+            "direct-transaction-evidence": "direct-transaction-evidence";
+            "heuristic-association": "heuristic-association";
+            "provider-index-assertion": "provider-index-assertion";
+        }>;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    alternativeExplanations: z.ZodArray<z.ZodString>;
+    unknowns: z.ZodArray<z.ZodString>;
+    limitations: z.ZodArray<z.ZodString>;
+    errors: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        message: z.ZodString;
+        step: z.ZodString;
+        evidenceId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"agentex.tool-evidence.v1">;
+        id: z.ZodString;
+        tool: z.ZodString;
+        capability: z.ZodEnum<{
+            "evm.read": "evm.read";
+            "http.read": "http.read";
+            "solana.read": "solana.read";
+        }>;
+        source: z.ZodObject<{
+            kind: z.ZodEnum<{
+                rpc: "rpc";
+                http: "http";
+                offline: "offline";
+            }>;
+            provider: z.ZodString;
+            method: z.ZodString;
+            documentationUrl: z.ZodNullable<z.ZodURL>;
+        }, z.core.$strict>;
+        chain: z.ZodString;
+        scope: z.ZodObject<{
+            subjects: z.ZodArray<z.ZodString>;
+            window: z.ZodNullable<z.ZodObject<{
+                unit: z.ZodEnum<{
+                    block: "block";
+                    slot: "slot";
+                }>;
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>>;
+            page: z.ZodNullable<z.ZodObject<{
+                index: z.ZodNumber;
+                size: z.ZodNumber;
+                cursor: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        request: z.ZodJSONSchema;
+        snapshot: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"evm-block">;
+            chainId: z.ZodNumber;
+            blockNumber: z.ZodString;
+            blockHash: z.ZodString;
+            timestamp: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"solana-slot">;
+            genesisHash: z.ZodString;
+            slot: z.ZodString;
+            commitment: z.ZodEnum<{
+                finalized: "finalized";
+                confirmed: "confirmed";
+            }>;
+            exactness: z.ZodEnum<{
+                "observed-context": "observed-context";
+                "lower-bound": "lower-bound";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"http-retrieval">;
+            retrievedAt: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"offline-input">;
+            inputHash: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        observedAt: z.ZodISODateTime;
+        finality: z.ZodEnum<{
+            finalized: "finalized";
+            "sequencer-confirmed": "sequencer-confirmed";
+            unverified: "unverified";
+            "not-applicable": "not-applicable";
+            confirmed: "confirmed";
+            "finalized-lower-bound": "finalized-lower-bound";
+            "confirmed-lower-bound": "confirmed-lower-bound";
+        }>;
+        canonicality: z.ZodEnum<{
+            "verified-at-completion": "verified-at-completion";
+            unchecked: "unchecked";
+            changed: "changed";
+            "not-applicable": "not-applicable";
+        }>;
+        completeness: z.ZodEnum<{
+            error: "error";
+            "complete-for-request": "complete-for-request";
+            unavailable: "unavailable";
+            truncated: "truncated";
+            "empty-result": "empty-result";
+        }>;
+        errorCategory: z.ZodNullable<z.ZodString>;
+        result: z.ZodJSONSchema;
+        contentHash: z.ZodString;
+        artifactHash: z.ZodString;
+        privacy: z.ZodEnum<{
+            "public-chain-data": "public-chain-data";
+            "public-web-content": "public-web-content";
+            "private-input": "private-input";
+        }>;
+        trust: z.ZodEnum<{
+            "chain-state": "chain-state";
+            "provider-assertion": "provider-assertion";
+            "untrusted-third-party-content": "untrusted-third-party-content";
+            "offline-decoding": "offline-decoding";
+        }>;
+    }, z.core.$strict>>;
+    analysis: z.ZodOptional<z.ZodObject<{
+        label: z.ZodLiteral<"AI-assisted summary">;
+        status: z.ZodEnum<{
+            skipped: "skipped";
+            completed: "completed";
+            unavailable: "unavailable";
+        }>;
+        model: z.ZodString;
+        findings: z.ZodArray<z.ZodObject<{
+            claim: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            confidence: z.ZodEnum<{
+                supported: "supported";
+                uncertain: "uncertain";
+            }>;
+        }, z.core.$strict>>;
+        unavailableReason: z.ZodOptional<z.ZodString>;
+    }, 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">;
+        model: z.ZodOptional<z.ZodObject<{
+            model: z.ZodString;
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            costMicrousd: z.ZodNumber;
+            costStatus: z.ZodOptional<z.ZodLiteral<"unresolved">>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type DeployerInvestigationReport = z.infer<typeof DeployerInvestigationReportSchema>;
+export declare const DEPLOYER_RESULT_CONTRACT: {
+    readonly id: "deployer-investigation-observed-v1";
+    readonly description: "Charge only for a complete investigation read at one pinned latest block (sequencer-confirmed) that is still canonical at completion: contract code observed, the creation block located with a captured receipt or archive code checks, and the funding and related-deployment sections read with their index coverage stated. A reorganization, an unlocated creation or any read error makes the report partial or failed and charges nothing. No identity, ownership, fraud or safety claim is made.";
+};
+export declare function deployerResultContractIssues(raw: unknown, manifest?: {
+    version: string;
+}): string[];
+export declare const satisfiesDeployerResultContract: (raw: unknown, manifest?: {
+    version: string;
+}) => boolean;
+export declare const validateDeployerReceipt: (evidence: unknown, input: DeployerInvestigationInput) => {
+    schemaVersion: "agentex.tool-evidence.v1";
+    id: string;
+    tool: string;
+    capability: "evm.read" | "http.read" | "solana.read";
+    source: {
+        kind: "rpc" | "http" | "offline";
+        provider: string;
+        method: string;
+        documentationUrl: string | null;
+    };
+    chain: string;
+    scope: {
+        subjects: string[];
+        window: {
+            unit: "block" | "slot";
+            from: string;
+            to: string;
+        } | null;
+        page: {
+            index: number;
+            size: number;
+            cursor: string | null;
+        } | null;
+    };
+    request: z.core.util.JSONType;
+    snapshot: {
+        kind: "evm-block";
+        chainId: number;
+        blockNumber: string;
+        blockHash: string;
+        timestamp: string | null;
+    } | {
+        kind: "solana-slot";
+        genesisHash: string;
+        slot: string;
+        commitment: "finalized" | "confirmed";
+        exactness: "observed-context" | "lower-bound";
+    } | {
+        kind: "http-retrieval";
+        retrievedAt: string;
+    } | {
+        kind: "offline-input";
+        inputHash: string;
+    } | null;
+    observedAt: string;
+    finality: "finalized" | "sequencer-confirmed" | "unverified" | "not-applicable" | "confirmed" | "finalized-lower-bound" | "confirmed-lower-bound";
+    canonicality: "verified-at-completion" | "unchecked" | "changed" | "not-applicable";
+    completeness: "error" | "complete-for-request" | "unavailable" | "truncated" | "empty-result";
+    errorCategory: string | null;
+    result: z.core.util.JSONType;
+    contentHash: string;
+    artifactHash: string;
+    privacy: "public-chain-data" | "public-web-content" | "private-input";
+    trust: "chain-state" | "provider-assertion" | "untrusted-third-party-content" | "offline-decoding";
+};
+export {};