agentex-creator-sdk 1.0.0

package/dist/packages/contracts/src/wallet-analysis.d.ts

@@ -0,0 +1,866 @@
+import { z } from 'zod';
+/**
+ * P03 Wallet Analyst contract. Input: an explicit chain and wallet, an optional block window and a transfer bound. Output: the native balance
+ * at the pinned block, bounded inbound and outbound transfers by category with exact amounts, per-asset flows without double-counted
+ * self-transfers, current token balances, and a transaction ledger (CSV in the run export). Trades are not classified, fees are not computed
+ * and realised or unrealised results, cost basis and win rate are reported as not computed because no verified price or trade source exists.
+ */
+export declare const WALLET_SCHEMA_ID: "agentex.wallet-analysis.v1";
+export declare const WALLET_TOOLS: readonly "evm.wallet-activity@0.1.0"[];
+/** Pin (2) + balance + two transfer pages + recheck. */
+export declare const WALLET_MINIMUM_RPC_CALLS = 6;
+export declare const WalletAnalysisInputSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+    }>;
+    wallet: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    fromBlock: z.ZodOptional<z.ZodString>;
+    toBlock: z.ZodOptional<z.ZodString>;
+    maximumTransfers: z.ZodDefault<z.ZodNumber>;
+    pricingDenomination: z.ZodOptional<z.ZodEnum<{
+        usd: "usd";
+    }>>;
+}, z.core.$strict>;
+export type WalletAnalysisInput = z.infer<typeof WalletAnalysisInputSchema>;
+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.wallet-analysis.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 WALLET_ANALYST_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.wallet-analysis.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 SupportedWalletAnalystManifestSchema: 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.wallet-analysis.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 WalletAnalystManifest = z.infer<typeof ManifestSchema>;
+/** Columns of the transaction ledger rows in the CSV run export (one row per transfer leg). */
+export declare const WALLET_LEDGER_COLUMNS: readonly string[];
+export declare const WalletAnalysisReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"agentex.wallet-analysis.v1">;
+    agentVersion: z.ZodString;
+    manifestHash: z.ZodString;
+    input: z.ZodObject<{
+        chain: z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+        }>;
+        wallet: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        fromBlock: z.ZodOptional<z.ZodString>;
+        toBlock: z.ZodOptional<z.ZodString>;
+        maximumTransfers: z.ZodDefault<z.ZodNumber>;
+        pricingDenomination: z.ZodOptional<z.ZodEnum<{
+            usd: "usd";
+        }>>;
+    }, 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>>;
+    activity: 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<{
+            order: z.ZodEnum<{
+                "oldest-first": "oldest-first";
+                "newest-first": "newest-first";
+            }>;
+            categories: z.ZodArray<z.ZodEnum<{
+                external: "external";
+                internal: "internal";
+                erc20: "erc20";
+                erc721: "erc721";
+                erc1155: "erc1155";
+            }>>;
+            inbound: z.ZodEnum<{
+                unavailable: "unavailable";
+                "provider-exhausted": "provider-exhausted";
+                "truncated-with-cursor": "truncated-with-cursor";
+                "not-read-call-bound": "not-read-call-bound";
+            }>;
+            outbound: z.ZodEnum<{
+                unavailable: "unavailable";
+                "provider-exhausted": "provider-exhausted";
+                "truncated-with-cursor": "truncated-with-cursor";
+                "not-read-call-bound": "not-read-call-bound";
+            }>;
+            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>>;
+        window: z.ZodObject<{
+            fromBlock: z.ZodString;
+            toBlock: z.ZodString;
+        }, z.core.$strict>;
+        wallet: z.ZodString;
+        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>>;
+        nativeBalance: z.ZodObject<{
+            balanceAtomic: 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">;
+            balanceFormatted: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        flows: z.ZodArray<z.ZodObject<{
+            asset: z.ZodString;
+            contract: z.ZodNullable<z.ZodString>;
+            category: z.ZodEnum<{
+                external: "external";
+                internal: "internal";
+                erc20: "erc20";
+                erc721: "erc721";
+                erc1155: "erc1155";
+            }>;
+            symbol: z.ZodNullable<z.ZodString>;
+            decimals: z.ZodNullable<z.ZodNumber>;
+            inboundAtomic: z.ZodString;
+            outboundAtomic: z.ZodString;
+            inboundFormatted: z.ZodNullable<z.ZodString>;
+            outboundFormatted: z.ZodNullable<z.ZodString>;
+            transfersIn: z.ZodNumber;
+            transfersOut: z.ZodNumber;
+            selfTransfers: z.ZodNumber;
+            unquantifiedTransfers: z.ZodNumber;
+        }, z.core.$strict>>;
+        transactions: z.ZodArray<z.ZodObject<{
+            transactionHash: z.ZodString;
+            blockNumber: z.ZodString;
+            blockTimestamp: z.ZodNullable<z.ZodString>;
+            legsIn: z.ZodNumber;
+            legsOut: z.ZodNumber;
+            classification: z.ZodEnum<{
+                "inbound-only": "inbound-only";
+                "outbound-only": "outbound-only";
+                "self-transfer": "self-transfer";
+                "in-and-out-same-transaction": "in-and-out-same-transaction";
+            }>;
+            note: z.ZodString;
+        }, z.core.$strict>>;
+        tokenBalances: z.ZodObject<{
+            status: z.ZodEnum<{
+                observed: "observed";
+                unavailable: "unavailable";
+                "not-read": "not-read";
+            }>;
+            finality: z.ZodLiteral<"provider-latest-not-pinned">;
+            balances: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                balanceAtomic: z.ZodNullable<z.ZodString>;
+                symbol: 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">;
+                decimals: 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">;
+                balanceFormatted: z.ZodNullable<z.ZodString>;
+                evidenceIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            nextPageKey: z.ZodNullable<z.ZodString>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        labelChecks: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    trades: z.ZodObject<{
+        status: z.ZodLiteral<"not-classified">;
+        reason: z.ZodString;
+    }, z.core.$strict>;
+    fees: z.ZodObject<{
+        status: z.ZodLiteral<"not-computed">;
+        reason: z.ZodString;
+        sourceGap: z.ZodEnum<{
+            "historical-prices": "historical-prices";
+            "trade-classification": "trade-classification";
+            "transaction-fees": "transaction-fees";
+        }>;
+    }, z.core.$strict>;
+    results: z.ZodObject<{
+        realised: z.ZodObject<{
+            status: z.ZodLiteral<"not-computed">;
+            reason: z.ZodString;
+            sourceGap: z.ZodEnum<{
+                "historical-prices": "historical-prices";
+                "trade-classification": "trade-classification";
+                "transaction-fees": "transaction-fees";
+            }>;
+        }, z.core.$strict>;
+        unrealised: z.ZodObject<{
+            status: z.ZodLiteral<"not-computed">;
+            reason: z.ZodString;
+            sourceGap: z.ZodEnum<{
+                "historical-prices": "historical-prices";
+                "trade-classification": "trade-classification";
+                "transaction-fees": "transaction-fees";
+            }>;
+        }, z.core.$strict>;
+        costBasis: z.ZodObject<{
+            status: z.ZodLiteral<"not-computed">;
+            reason: z.ZodString;
+            sourceGap: z.ZodEnum<{
+                "historical-prices": "historical-prices";
+                "trade-classification": "trade-classification";
+                "transaction-fees": "transaction-fees";
+            }>;
+        }, z.core.$strict>;
+        winRate: z.ZodObject<{
+            status: z.ZodLiteral<"not-computed">;
+            reason: z.ZodString;
+            sourceGap: z.ZodEnum<{
+                "historical-prices": "historical-prices";
+                "trade-classification": "trade-classification";
+                "transaction-fees": "transaction-fees";
+            }>;
+        }, z.core.$strict>;
+        valuationDenomination: z.ZodNullable<z.ZodEnum<{
+            usd: "usd";
+        }>>;
+    }, z.core.$strict>;
+    ledger: z.ZodObject<{
+        format: z.ZodLiteral<"csv-in-run-export">;
+        rows: z.ZodNumber;
+        columns: z.ZodArray<z.ZodString>;
+    }, 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>>;
+    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 WalletAnalysisReport = z.infer<typeof WalletAnalysisReportSchema>;
+export declare const WALLET_RESULT_CONTRACT: {
+    readonly id: "wallet-analysis-observed-v1";
+    readonly description: "Charge only for a complete analysis read at one pinned latest block (sequencer-confirmed) that is still canonical at completion: the native balance observed, both inbound and outbound transfer pages read with exact amounts and their index coverage stated, and the transaction ledger included. Trades, fees, cost basis, realised and unrealised results and win rate are never claimed. A reorganization or any read error makes the report partial or failed and charges nothing.";
+};
+export declare function walletResultContractIssues(raw: unknown, manifest?: {
+    version: string;
+}): string[];
+export declare const satisfiesWalletResultContract: (raw: unknown, manifest?: {
+    version: string;
+}) => boolean;
+export declare const validateWalletReceipt: (evidence: unknown, input: WalletAnalysisInput) => {
+    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 {};