agentex-creator-sdk 1.0.0

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

@@ -0,0 +1,451 @@
+import { z } from 'zod';
+/**
+ * Solana Transaction Inspector contract (P05, Solana half). A proposed legacy/v0 payload is decoded offline, address
+ * lookup tables are resolved at `confirmed` commitment with a lower-bound slot (`minContextSlot`; the report field keeps its
+ * historical name `finalizedSlotLowerBound`) and `simulateTransaction` runs with `sigVerify: false` and
+ * `replaceRecentBlockhash: true`. Nothing is signed or broadcast and no key is requested. `analysisChain` is independent
+ * of the account's EVM sign-in and funding network, so an EVM-funded user needs no Solana signature (C04).
+ */
+export declare const SOLANA_INSPECTION_SCHEMA_ID: "agentex.solana-transaction-inspection.v1";
+export declare const SOLANA_INSPECTION_TOOL: "solana.inspect-transaction@0.1.0";
+export declare const SOLANA_INSPECTION_RPC_CEILING = 6;
+export declare const SOLANA_INSPECTION_RPC_METHODS: readonly ["getGenesisHash", "getSlot", "getMultipleAccounts", "simulateTransaction"];
+export declare const SolanaNetworkSchema: z.ZodEnum<{
+    "mainnet-beta": "mainnet-beta";
+    devnet: "devnet";
+}>;
+/** There is deliberately no keypair, signer secret, RPC URL, commitment override or broadcast field. */
+export declare const SolanaTransactionInspectionInputSchema: z.ZodObject<{
+    analysisChain: z.ZodLiteral<"solana">;
+    network: z.ZodEnum<{
+        "mainnet-beta": "mainnet-beta";
+        devnet: "devnet";
+    }>;
+    encoding: z.ZodEnum<{
+        message: "message";
+        transaction: "transaction";
+    }>;
+    payloadBase64: z.ZodString;
+    simulate: z.ZodDefault<z.ZodBoolean>;
+    accounts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type SolanaTransactionInspectionInput = z.infer<typeof SolanaTransactionInspectionInputSchema>;
+export declare const SolanaPermissionEffectSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "sol-transfer": "sol-transfer";
+        "token-transfer": "token-transfer";
+        "token-approval": "token-approval";
+        "token-approval-revoked": "token-approval-revoked";
+        "authority-change": "authority-change";
+        "account-close": "account-close";
+        "account-owner-assigned": "account-owner-assigned";
+        "account-creation": "account-creation";
+        mint: "mint";
+        burn: "burn";
+        freeze: "freeze";
+        thaw: "thaw";
+        "nonce-advance": "nonce-advance";
+        "nonce-authority-change": "nonce-authority-change";
+        "nonce-withdraw": "nonce-withdraw";
+        "permanent-delegate": "permanent-delegate";
+        "mint-authorities-declared": "mint-authorities-declared";
+    }>;
+    account: z.ZodNullable<z.ZodString>;
+    counterparty: z.ZodNullable<z.ZodString>;
+    authority: z.ZodNullable<z.ZodString>;
+    amountAtomic: z.ZodNullable<z.ZodString>;
+    decimals: z.ZodNullable<z.ZodNumber>;
+    amountFormatted: z.ZodNullable<z.ZodString>;
+    note: z.ZodString;
+}, z.core.$strict>;
+export declare const SolanaInspectionFindingCodeSchema: z.ZodEnum<{
+    "sol-transfer": "sol-transfer";
+    "token-approval": "token-approval";
+    "authority-change": "authority-change";
+    "account-close": "account-close";
+    "account-owner-assigned": "account-owner-assigned";
+    "permanent-delegate": "permanent-delegate";
+    "unknown-instruction": "unknown-instruction";
+    "invalid-instruction": "invalid-instruction";
+    "unresolved-account": "unresolved-account";
+    "unlimited-token-approval": "unlimited-token-approval";
+    "authority-removed": "authority-removed";
+    "durable-nonce-lifetime": "durable-nonce-lifetime";
+    "associated-account-mismatch": "associated-account-mismatch";
+    "deactivated-lookup-table": "deactivated-lookup-table";
+    "simulation-failed": "simulation-failed";
+    "simulation-not-run": "simulation-not-run";
+    "duplicate-compute-budget": "duplicate-compute-budget";
+    "signatures-present-not-verified": "signatures-present-not-verified";
+}>;
+export declare const SolanaTransactionInspectionReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"agentex.solana-transaction-inspection.v1">;
+    agentVersion: z.ZodString;
+    parserVersion: z.ZodString;
+    input: z.ZodObject<{
+        analysisChain: z.ZodLiteral<"solana">;
+        network: z.ZodEnum<{
+            "mainnet-beta": "mainnet-beta";
+            devnet: "devnet";
+        }>;
+        encoding: z.ZodEnum<{
+            message: "message";
+            transaction: "transaction";
+        }>;
+        payloadBase64: z.ZodString;
+        simulate: z.ZodDefault<z.ZodBoolean>;
+        accounts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+        failed: "failed";
+    }>;
+    generatedAt: z.ZodISODateTime;
+    network: z.ZodEnum<{
+        "mainnet-beta": "mainnet-beta";
+        devnet: "devnet";
+    }>;
+    genesisHash: z.ZodNullable<z.ZodString>;
+    finalizedSlotLowerBound: z.ZodNullable<z.ZodString>;
+    payload: z.ZodObject<{
+        encoding: z.ZodEnum<{
+            message: "message";
+            transaction: "transaction";
+        }>;
+        version: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"legacy">, z.ZodLiteral<0>]>>;
+        bytes: z.ZodNumber;
+        sha256: z.ZodString;
+        messageSha256: z.ZodNullable<z.ZodString>;
+        feePayer: z.ZodNullable<z.ZodString>;
+        recentBlockhashOrNonce: z.ZodNullable<z.ZodString>;
+        lifetime: z.ZodEnum<{
+            unknown: "unknown";
+            "recent-blockhash": "recent-blockhash";
+            "durable-nonce": "durable-nonce";
+        }>;
+        header: z.ZodNullable<z.ZodObject<{
+            numRequiredSignatures: z.ZodNumber;
+            numReadonlySigned: z.ZodNumber;
+            numReadonlyUnsigned: z.ZodNumber;
+        }, z.core.$strict>>;
+        signatures: z.ZodArray<z.ZodObject<{
+            signer: z.ZodString;
+            present: z.ZodBoolean;
+        }, z.core.$strict>>;
+        signaturesVerified: z.ZodLiteral<false>;
+    }, z.core.$strict>;
+    lookupTables: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        status: z.ZodEnum<{
+            unavailable: "unavailable";
+            resolved: "resolved";
+            "not-found": "not-found";
+            "not-a-lookup-table": "not-a-lookup-table";
+            "invalid-index": "invalid-index";
+        }>;
+        active: z.ZodNullable<z.ZodBoolean>;
+        authority: z.ZodNullable<z.ZodString>;
+        addressCount: z.ZodNullable<z.ZodNumber>;
+        loadedWritable: z.ZodArray<z.ZodNullable<z.ZodString>>;
+        loadedReadonly: z.ZodArray<z.ZodNullable<z.ZodString>>;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    accounts: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        address: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            unresolved: "unresolved";
+            static: "static";
+            "lookup-table": "lookup-table";
+        }>;
+        signer: z.ZodBoolean;
+        writable: z.ZodBoolean;
+        label: z.ZodNullable<z.ZodString>;
+        isPerson: z.ZodLiteral<false>;
+    }, z.core.$strict>>;
+    instructions: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        programId: z.ZodNullable<z.ZodString>;
+        program: z.ZodEnum<{
+            unknown: "unknown";
+            system: "system";
+            "spl-token": "spl-token";
+            "token-2022": "token-2022";
+            "associated-token-account": "associated-token-account";
+            memo: "memo";
+            "compute-budget": "compute-budget";
+        }>;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            decoded: "decoded";
+            invalid: "invalid";
+            "unresolved-program": "unresolved-program";
+        }>;
+        type: z.ZodNullable<z.ZodString>;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        accounts: z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            address: z.ZodNullable<z.ZodString>;
+            signer: z.ZodBoolean;
+            writable: z.ZodBoolean;
+            source: z.ZodEnum<{
+                unresolved: "unresolved";
+                static: "static";
+                "lookup-table": "lookup-table";
+            }>;
+        }, z.core.$strict>>;
+        effects: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                "sol-transfer": "sol-transfer";
+                "token-transfer": "token-transfer";
+                "token-approval": "token-approval";
+                "token-approval-revoked": "token-approval-revoked";
+                "authority-change": "authority-change";
+                "account-close": "account-close";
+                "account-owner-assigned": "account-owner-assigned";
+                "account-creation": "account-creation";
+                mint: "mint";
+                burn: "burn";
+                freeze: "freeze";
+                thaw: "thaw";
+                "nonce-advance": "nonce-advance";
+                "nonce-authority-change": "nonce-authority-change";
+                "nonce-withdraw": "nonce-withdraw";
+                "permanent-delegate": "permanent-delegate";
+                "mint-authorities-declared": "mint-authorities-declared";
+            }>;
+            account: z.ZodNullable<z.ZodString>;
+            counterparty: z.ZodNullable<z.ZodString>;
+            authority: z.ZodNullable<z.ZodString>;
+            amountAtomic: z.ZodNullable<z.ZodString>;
+            decimals: z.ZodNullable<z.ZodNumber>;
+            amountFormatted: z.ZodNullable<z.ZodString>;
+            note: z.ZodString;
+        }, z.core.$strict>>;
+        notes: z.ZodArray<z.ZodString>;
+        dataBytes: z.ZodNumber;
+        dataSha256: z.ZodString;
+        associatedAccountCheck: z.ZodEnum<{
+            "not-applicable": "not-applicable";
+            unresolved: "unresolved";
+            matches: "matches";
+            mismatch: "mismatch";
+        }>;
+    }, z.core.$strict>>;
+    permissions: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "sol-transfer": "sol-transfer";
+            "token-transfer": "token-transfer";
+            "token-approval": "token-approval";
+            "token-approval-revoked": "token-approval-revoked";
+            "authority-change": "authority-change";
+            "account-close": "account-close";
+            "account-owner-assigned": "account-owner-assigned";
+            "account-creation": "account-creation";
+            mint: "mint";
+            burn: "burn";
+            freeze: "freeze";
+            thaw: "thaw";
+            "nonce-advance": "nonce-advance";
+            "nonce-authority-change": "nonce-authority-change";
+            "nonce-withdraw": "nonce-withdraw";
+            "permanent-delegate": "permanent-delegate";
+            "mint-authorities-declared": "mint-authorities-declared";
+        }>;
+        account: z.ZodNullable<z.ZodString>;
+        counterparty: z.ZodNullable<z.ZodString>;
+        authority: z.ZodNullable<z.ZodString>;
+        amountAtomic: z.ZodNullable<z.ZodString>;
+        decimals: z.ZodNullable<z.ZodNumber>;
+        amountFormatted: z.ZodNullable<z.ZodString>;
+        note: z.ZodString;
+        instructionIndex: z.ZodNumber;
+    }, z.core.$strict>>;
+    computeBudget: z.ZodObject<{
+        unitLimit: z.ZodNullable<z.ZodString>;
+        unitPriceMicroLamports: z.ZodNullable<z.ZodString>;
+        priorityFeeLamportsAtLimit: z.ZodNullable<z.ZodString>;
+        heapBytes: z.ZodNullable<z.ZodString>;
+        loadedAccountsDataSizeLimit: z.ZodNullable<z.ZodString>;
+        duplicateInstructions: z.ZodBoolean;
+        note: z.ZodString;
+    }, z.core.$strict>;
+    simulation: z.ZodObject<{
+        semantics: z.ZodLiteral<"simulateTransaction-at-context-slot-not-a-guarantee">;
+        status: z.ZodEnum<{
+            error: "error";
+            failed: "failed";
+            "not-run": "not-run";
+            succeeded: "succeeded";
+        }>;
+        reason: z.ZodString;
+        slot: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodJSONSchema>;
+        logs: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        unitsConsumed: z.ZodNullable<z.ZodString>;
+        replacementBlockhash: z.ZodNullable<z.ZodString>;
+        signaturesVerified: z.ZodLiteral<false>;
+        recentBlockhashReplaced: z.ZodBoolean;
+        broadcast: z.ZodLiteral<false>;
+        accounts: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            status: z.ZodEnum<{
+                observed: "observed";
+                absent: "absent";
+                "not-returned": "not-returned";
+            }>;
+            owner: z.ZodNullable<z.ZodString>;
+            lamports: z.ZodNullable<z.ZodString>;
+            dataBytes: z.ZodNullable<z.ZodNumber>;
+            dataSha256: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        innerInstructionGroups: z.ZodNullable<z.ZodNumber>;
+        returnData: z.ZodNullable<z.ZodObject<{
+            programId: z.ZodString;
+            dataBase64: z.ZodString;
+        }, z.core.$strict>>;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    findings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            "sol-transfer": "sol-transfer";
+            "token-approval": "token-approval";
+            "authority-change": "authority-change";
+            "account-close": "account-close";
+            "account-owner-assigned": "account-owner-assigned";
+            "permanent-delegate": "permanent-delegate";
+            "unknown-instruction": "unknown-instruction";
+            "invalid-instruction": "invalid-instruction";
+            "unresolved-account": "unresolved-account";
+            "unlimited-token-approval": "unlimited-token-approval";
+            "authority-removed": "authority-removed";
+            "durable-nonce-lifetime": "durable-nonce-lifetime";
+            "associated-account-mismatch": "associated-account-mismatch";
+            "deactivated-lookup-table": "deactivated-lookup-table";
+            "simulation-failed": "simulation-failed";
+            "simulation-not-run": "simulation-not-run";
+            "duplicate-compute-budget": "duplicate-compute-budget";
+            "signatures-present-not-verified": "signatures-present-not-verified";
+        }>;
+        message: z.ZodString;
+        instructionIndexes: z.ZodArray<z.ZodNumber>;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    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>>;
+    usage: z.ZodObject<{
+        rpcCalls: z.ZodNumber;
+        maximumRpcCalls: z.ZodNumber;
+        elapsedMs: z.ZodNumber;
+        modelTokens: z.ZodLiteral<0>;
+        providerCostStatus: z.ZodLiteral<"unpriced">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SolanaTransactionInspectionReport = z.infer<typeof SolanaTransactionInspectionReportSchema>;

package/dist/packages/contracts/src/solana-inspection.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { ToolEvidenceItemSchema } from './workflow.js';
+/**
+ * Solana Transaction Inspector contract (P05, Solana half). A proposed legacy/v0 payload is decoded offline, address
+ * lookup tables are resolved at `confirmed` commitment with a lower-bound slot (`minContextSlot`; the report field keeps its
+ * historical name `finalizedSlotLowerBound`) and `simulateTransaction` runs with `sigVerify: false` and
+ * `replaceRecentBlockhash: true`. Nothing is signed or broadcast and no key is requested. `analysisChain` is independent
+ * of the account's EVM sign-in and funding network, so an EVM-funded user needs no Solana signature (C04).
+ */
+export const SOLANA_INSPECTION_SCHEMA_ID = 'agentex.solana-transaction-inspection.v1';
+export const SOLANA_INSPECTION_TOOL = 'solana.inspect-transaction@0.1.0';
+export const SOLANA_INSPECTION_RPC_CEILING = 6;
+export const SOLANA_INSPECTION_RPC_METHODS = ['getGenesisHash', 'getSlot', 'getMultipleAccounts', 'simulateTransaction'];
+export const SolanaNetworkSchema = z.enum(['mainnet-beta', 'devnet']);
+const Base58Key = z.string().regex(/^[1-9A-HJ-NP-Za-km-z]{32,44}$/);
+const Hash = z.string().regex(/^[a-f0-9]{64}$/);
+const Exact = z.string().regex(/^(0|[1-9][0-9]{0,77})$/);
+const Canonical64 = z.string().min(4).max(1644).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/, 'Expected canonical base64');
+/** There is deliberately no keypair, signer secret, RPC URL, commitment override or broadcast field. */
+export const SolanaTransactionInspectionInputSchema = z.strictObject({
+    analysisChain: z.literal('solana'), network: SolanaNetworkSchema, encoding: z.enum(['transaction', 'message']), payloadBase64: Canonical64,
+    simulate: z.boolean().default(true), accounts: z.array(Base58Key).max(8).default([]),
+});
+const Value = z.union([z.string().max(1024), z.number(), z.boolean(), z.null()]);
+const Program = z.enum(['system', 'spl-token', 'token-2022', 'associated-token-account', 'memo', 'compute-budget', 'unknown']);
+export const SolanaPermissionEffectSchema = z.strictObject({
+    kind: z.enum(['sol-transfer', 'token-transfer', 'token-approval', 'token-approval-revoked', 'authority-change', 'account-close', 'account-owner-assigned', 'account-creation', 'mint', 'burn', 'freeze', 'thaw', 'nonce-advance', 'nonce-authority-change', 'nonce-withdraw', 'permanent-delegate', 'mint-authorities-declared']),
+    account: Base58Key.nullable(), counterparty: Base58Key.nullable(), authority: Base58Key.nullable(), amountAtomic: Exact.nullable(), decimals: z.number().int().min(0).max(255).nullable(), amountFormatted: z.string().max(100).nullable(), note: z.string().max(500),
+});
+const AccountSource = z.enum(['static', 'lookup-table', 'unresolved']);
+export const SolanaInspectionFindingCodeSchema = z.enum(['unknown-instruction', 'invalid-instruction', 'unresolved-account', 'token-approval', 'unlimited-token-approval', 'authority-change', 'authority-removed', 'account-close',
+    'account-owner-assigned', 'sol-transfer', 'durable-nonce-lifetime', 'permanent-delegate', 'associated-account-mismatch', 'deactivated-lookup-table', 'simulation-failed', 'simulation-not-run', 'duplicate-compute-budget', 'signatures-present-not-verified']);
+export const SolanaTransactionInspectionReportSchema = z.strictObject({
+    schemaVersion: z.literal(SOLANA_INSPECTION_SCHEMA_ID), agentVersion: z.string().regex(/^\d+\.\d+\.\d+$/), parserVersion: z.string().regex(/^\d+\.\d+\.\d+$/),
+    input: SolanaTransactionInspectionInputSchema, status: z.enum(['complete', 'partial', 'failed']), generatedAt: z.iso.datetime(),
+    network: SolanaNetworkSchema, genesisHash: z.string().nullable(), finalizedSlotLowerBound: Exact.nullable(),
+    payload: z.strictObject({
+        encoding: z.enum(['transaction', 'message']), version: z.union([z.literal('legacy'), z.literal(0)]).nullable(), bytes: z.number().int().min(0).max(1232), sha256: Hash, messageSha256: Hash.nullable(),
+        feePayer: Base58Key.nullable(), recentBlockhashOrNonce: Base58Key.nullable(), lifetime: z.enum(['recent-blockhash', 'durable-nonce', 'unknown']),
+        header: z.strictObject({ numRequiredSignatures: z.number().int(), numReadonlySigned: z.number().int(), numReadonlyUnsigned: z.number().int() }).nullable(),
+        signatures: z.array(z.strictObject({ signer: Base58Key, present: z.boolean() })).max(64), signaturesVerified: z.literal(false),
+    }),
+    lookupTables: z.array(z.strictObject({ address: Base58Key, status: z.enum(['resolved', 'not-found', 'not-a-lookup-table', 'invalid-index', 'unavailable']), active: z.boolean().nullable(), authority: Base58Key.nullable(), addressCount: z.number().int().nullable(),
+        loadedWritable: z.array(Base58Key.nullable()).max(64), loadedReadonly: z.array(Base58Key.nullable()).max(64), evidenceIds: z.array(z.string()) })).max(16),
+    accounts: z.array(z.strictObject({ index: z.number().int().min(0).max(255), address: Base58Key.nullable(), source: AccountSource, signer: z.boolean(), writable: z.boolean(), label: z.string().max(100).nullable(), isPerson: z.literal(false) })).max(256),
+    instructions: z.array(z.strictObject({
+        index: z.number().int().min(0).max(63), programId: Base58Key.nullable(), program: Program, status: z.enum(['decoded', 'unknown', 'invalid', 'unresolved-program']), type: z.string().max(64).nullable(),
+        arguments: z.record(z.string().max(96), Value), accounts: z.array(z.strictObject({ role: z.string().max(64), address: Base58Key.nullable(), signer: z.boolean(), writable: z.boolean(), source: AccountSource })).max(64),
+        effects: z.array(SolanaPermissionEffectSchema).max(8), notes: z.array(z.string().max(600)).max(8), dataBytes: z.number().int().min(0).max(1232), dataSha256: Hash,
+        associatedAccountCheck: z.enum(['matches', 'mismatch', 'not-applicable', 'unresolved']),
+    })).max(64),
+    permissions: z.array(SolanaPermissionEffectSchema.extend({ instructionIndex: z.number().int().min(0).max(63) })).max(128),
+    computeBudget: z.strictObject({ unitLimit: Exact.nullable(), unitPriceMicroLamports: Exact.nullable(), priorityFeeLamportsAtLimit: Exact.nullable(), heapBytes: Exact.nullable(), loadedAccountsDataSizeLimit: Exact.nullable(), duplicateInstructions: z.boolean(), note: z.string().max(500) }),
+    simulation: z.strictObject({
+        semantics: z.literal('simulateTransaction-at-context-slot-not-a-guarantee'), status: z.enum(['succeeded', 'failed', 'error', 'not-run']), reason: z.string().max(1000), slot: Exact.nullable(),
+        error: z.json().nullable(), logs: z.array(z.string().max(2048)).max(250).nullable(), unitsConsumed: Exact.nullable(), replacementBlockhash: z.string().max(44).nullable(),
+        signaturesVerified: z.literal(false), recentBlockhashReplaced: z.boolean(), broadcast: z.literal(false),
+        accounts: z.array(z.strictObject({ address: Base58Key, status: z.enum(['observed', 'absent', 'not-returned']), owner: Base58Key.nullable(), lamports: Exact.nullable(), dataBytes: z.number().int().nullable(), dataSha256: Hash.nullable() })).max(8),
+        innerInstructionGroups: z.number().int().nullable(), returnData: z.strictObject({ programId: Base58Key, dataBase64: z.string().max(1644) }).nullable(), evidenceIds: z.array(z.string()),
+    }),
+    findings: z.array(z.strictObject({ code: SolanaInspectionFindingCodeSchema, message: z.string().max(1000), instructionIndexes: z.array(z.number().int()).max(64), evidenceIds: z.array(z.string()) })).max(64),
+    limitations: z.array(z.string().max(1000)).max(24), errors: z.array(z.strictObject({ category: z.string().regex(/^[a-z][a-z-]{1,63}$/), message: z.string().max(1000), step: z.string().max(64), evidenceId: z.string().optional() })).max(32),
+    evidence: z.array(ToolEvidenceItemSchema).max(SOLANA_INSPECTION_RPC_CEILING),
+    usage: z.strictObject({ rpcCalls: z.number().int().nonnegative(), maximumRpcCalls: z.number().int().positive().max(SOLANA_INSPECTION_RPC_CEILING), elapsedMs: z.number().int().nonnegative(), modelTokens: z.literal(0), providerCostStatus: z.literal('unpriced') }),
+}).superRefine((report, ctx) => {
+    const issue = (message) => ctx.addIssue({ code: 'custom', message });
+    const ids = new Set(report.evidence.map((item) => item.id));
+    if (ids.size !== report.evidence.length)
+        issue('Duplicate evidence id');
+    if (report.usage.rpcCalls > report.usage.maximumRpcCalls || report.evidence.length > report.usage.rpcCalls)
+        issue('RPC usage or evidence count exceeds the recorded budget.');
+    for (const item of report.evidence) {
+        if (item.tool !== SOLANA_INSPECTION_TOOL || item.capability !== 'solana.read')
+            issue(`Evidence ${item.id} was not produced by ${SOLANA_INSPECTION_TOOL}.`);
+        // Read-method allowlist: sending, airdrop and signing methods can never appear in a valid report.
+        if (!SOLANA_INSPECTION_RPC_METHODS.includes(item.source.method))
+            issue(`Unsupported Solana inspector RPC method ${item.source.method}`);
+        if (item.source.method === 'simulateTransaction' && item.privacy !== 'private-input')
+            issue('Simulation receipts carry the private proposed payload.');
+    }
+    const references = [...report.lookupTables.flatMap((table) => table.evidenceIds), ...report.simulation.evidenceIds, ...report.findings.flatMap((finding) => finding.evidenceIds), ...report.errors.flatMap((error) => error.evidenceId ? [error.evidenceId] : [])];
+    for (const id of references)
+        if (!ids.has(id))
+            issue(`Unknown evidence reference ${id}`);
+    const indexes = new Set(report.instructions.map((item) => item.index));
+    for (const finding of report.findings)
+        for (const index of finding.instructionIndexes)
+            if (!indexes.has(index))
+                issue(`Unknown instruction reference ${index}`);
+    if (['succeeded', 'failed'].includes(report.simulation.status) && !report.simulation.evidenceIds.length)
+        issue('A simulation outcome needs its captured simulateTransaction receipt.');
+    if (report.simulation.status === 'not-run' && report.simulation.evidenceIds.length)
+        issue('A simulation that did not run cannot cite receipts.');
+});