gate-evm-tools 1.0.28 → 1.2.0

package/dist-runtime/delivery/export.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.immutableDeliveryPlan = immutableDeliveryPlan;
+exports.validateDeliveryProgress = validateDeliveryProgress;
+exports.renderDeliveryExport = renderDeliveryExport;
+exports.exportDelivery = exportDelivery;
+/** Independent artifact delivery: no planning, execution, chain access or filesystem effects. */
+const canonicalData_1 = require("../workflow/lib/canonicalData");
+const data_1 = require("./data");
+const plan_1 = require("./plan");
+const observations_1 = require("./observations");
+/** Require canonical sealed input without silently normalizing quantities, case or ordering. */
+function immutableDeliveryPlan(raw) {
+    const data = (0, data_1.strictData)(raw, 'sealed delivery plan'), plan = (0, plan_1.parseDeliveryPlan)(data);
+    if ((0, canonicalData_1.canonicalJson)(data) !== (0, canonicalData_1.canonicalJson)(plan))
+        throw new Error('Expected canonical immutable delivery plan');
+    return plan;
+}
+const trustedProgress = new WeakMap();
+const progressPlans = new WeakMap();
+/** Explicit trusted I/O boundary, separate from formatting. Only this live result can mark completion. */
+async function validateDeliveryProgress(input) {
+    const plan = immutableDeliveryPlan(input.plan), references = (0, data_1.strictData)(input.completed ?? [], 'completed observation references');
+    if (!Array.isArray(references) || references.length > plan.transactions.length)
+        throw new Error('Invalid completed prefix');
+    if (references.length && typeof input.finalized?.readFinalized !== 'function')
+        throw new Error('Completed progress requires trusted finalized provenance');
+    const completed = [];
+    const seen = new Set();
+    for (const [i, ref] of references.entries()) {
+        (0, canonicalData_1.nonempty)(ref, 'observation reference');
+        if (seen.has(ref))
+            throw new Error('Duplicate completed observation');
+        seen.add(ref);
+        const o = (0, observations_1.parseObservation)(await input.finalized.readFinalized(ref), plan, i);
+        if (o.observationId !== ref || o.state !== 'finalized-success')
+            throw new Error('Completed prefix requires verified finalized success');
+        completed.push(o);
+    }
+    const token = Object.freeze(Object.create(null));
+    trustedProgress.set(token, (0, canonicalData_1.deepFreeze)(completed));
+    progressPlans.set(token, plan.planHash);
+    return token;
+}
+/** Pure renderer. No callback, filesystem or chain access; serialized tokens convey no provenance. */
+function renderDeliveryExport(rawPlan, progress) {
+    const plan = immutableDeliveryPlan(rawPlan);
+    const completed = progress === undefined ? [] : trustedProgress.get(progress);
+    if (!completed || (progress !== undefined && progressPlans.get(progress) !== plan.planHash))
+        throw new Error('Untrusted or mismatched validated progress');
+    const start = completed.length;
+    let end = start;
+    if (start < plan.transactions.length) {
+        const first = plan.transactions[start];
+        while (end < plan.transactions.length && plan.transactions[end].route === first.route && plan.transactions[end].executor === first.executor)
+            end++;
+    }
+    const model = (0, canonicalData_1.deepFreeze)({ version: 1, schema: 'gate-delivery-export', status: 'artifact-delivered', plan, fullRange: { start: 0, end: plan.transactions.length }, actionableRange: start === end ? null : { start, end }, completed, dependencies: plan.transactions.map((tx, i) => ({ transactionId: tx.transactionId, after: i ? [plan.transactions[i - 1].transactionId] : [] })) });
+    const json = (0, canonicalData_1.canonicalJson)(model);
+    // One complete canonical model in both formats prevents abbreviated calldata or split projections.
+    const markdown = `# Delivery calldata\n\nArtifact delivered. This export does not indicate deployment or grant execution authority.\n\nFull range: [${model.fullRange.start}, ${model.fullRange.end}).\nCurrent actionable range: ${model.actionableRange ? `[${start}, ${end})` : 'none'}. All transactions follow their predecessors.\n\n\`\`\`json\n${json}\n\`\`\`\n`;
+    return (0, canonicalData_1.deepFreeze)({ model, json, markdown });
+}
+/** Convenience wrapper: resolves trusted provenance first, then invokes the pure renderer. */
+async function exportDelivery(input) {
+    const plan = immutableDeliveryPlan(input.plan);
+    return renderDeliveryExport(plan, await validateDeliveryProgress({ ...input, plan }));
+}
+//# sourceMappingURL=export.js.map

package/dist-runtime/delivery/export.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.js","sourceRoot":"","sources":["../../runtime/delivery/export.ts"],"names":[],"mappings":"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"}

package/dist-runtime/delivery/forkAudit.d.ts

@@ -0,0 +1,119 @@
+import type { CompletedExecutionTransaction, ReleaseExecutionTransaction } from "../workflow/lib/transactionPlanner";
+export interface CapturedForkInterval {
+    readonly snapshot: Omit<ForkAuditEvidence, "planHash" | "evidenceHash">;
+    assertUnchanged(): Promise<void>;
+    bind(planHash: string): ForkAuditEvidence;
+}
+export interface AuditProvider {
+    request(input: {
+        method: string;
+        params?: any;
+    }): Promise<any>;
+    send?(method: string, params?: any): Promise<any>;
+}
+interface BlockIdentity {
+    number: number;
+    hash: string;
+    parentHash: string;
+}
+interface TransactionEvidence {
+    hash: string;
+    from: string;
+    to: string;
+    value: string;
+    data: string;
+    blockNumber: number;
+    blockHash: string;
+    transactionIndex: number;
+    receipt: {
+        hash: string;
+        from: string;
+        to: string;
+        blockNumber: number;
+        blockHash: string;
+        transactionIndex: number;
+        status: 1;
+    };
+}
+export interface ForkAuditEvidence {
+    version: 1;
+    planHash: string;
+    chainId: string;
+    provider: {
+        kind: "hardhat";
+        instanceId: string;
+    };
+    sourceSnapshot: {
+        blockNumber: number;
+        blockHash: string;
+    };
+    baseline: BlockIdentity;
+    end: BlockIdentity;
+    blocks: (BlockIdentity & {
+        transactionHashes: string[];
+    })[];
+    transactions: TransactionEvidence[];
+    submissions: CompletedExecutionTransaction[];
+    completedTransactions: CompletedExecutionTransaction[];
+    setup: {
+        method: string;
+        address: string;
+        value?: string;
+    }[];
+    evidenceHash: string;
+}
+interface AuditExpectation {
+    completedTransactions?: readonly CompletedExecutionTransaction[];
+    transactions: readonly ReleaseExecutionTransaction[];
+    planHash: string;
+    chainId: string;
+    sourceSnapshot: {
+        blockNumber: number;
+        blockHash: string;
+    };
+}
+/** Pure verification of captured local evidence. Never evaluates scripts or reads source business state. */
+export declare function verifyCapturedForkAudit(raw: unknown, expected: AuditExpectation): ForkAuditEvidence;
+/** Guard covers this explicit provider's public request/send boundary. No same-UID isolation claim. */
+export declare class LocalForkAudit {
+    private readonly input;
+    private readonly baseline;
+    private readonly instanceId;
+    private readonly scope;
+    private readonly submissions;
+    private readonly setupObservations;
+    private violation;
+    private closed;
+    private readonly originalRequest;
+    private readonly originalSend?;
+    private readonly guardedRequest;
+    private readonly guardedSend;
+    private constructor();
+    static start(input: {
+        provider: AuditProvider;
+        chainId: string;
+        sourceSnapshot: {
+            blockNumber: number;
+            blockHash: string;
+        };
+    }): Promise<LocalForkAudit>;
+    private captured;
+    private guard;
+    setup<T>(executor: string, action: () => Promise<T>): Promise<T>;
+    record(observation: CompletedExecutionTransaction): void;
+    private rpc;
+    private assertSettled;
+    finish(input: {
+        transactions: readonly ReleaseExecutionTransaction[];
+        completedTransactions: CompletedExecutionTransaction[];
+        planHash: string;
+    }): Promise<ForkAuditEvidence>;
+    /** Owner-held interval. No final plan identity exists until its one-shot pure binding. */
+    capture(input: {
+        transactions: readonly ReleaseExecutionTransaction[];
+        completedTransactions: CompletedExecutionTransaction[];
+    }): Promise<CapturedForkInterval>;
+    private readInterval;
+    close(): void;
+}
+export {};

package/dist-runtime/delivery/forkAudit.js

@@ -0,0 +1,473 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalForkAudit = void 0;
+exports.verifyCapturedForkAudit = verifyCapturedForkAudit;
+const node_async_hooks_1 = require("node:async_hooks");
+const canonicalData_1 = require("../workflow/lib/canonicalData");
+const hash = (v) => {
+    if (typeof v !== "string" || !/^0x[\da-fA-F]{64}$/.test(v))
+        throw new Error("Invalid audit hash");
+    return v.toLowerCase();
+};
+const address = (v) => {
+    if (typeof v !== "string" || !/^0x[\da-fA-F]{40}$/.test(v))
+        throw new Error("Invalid audit address");
+    return v.toLowerCase();
+};
+const quantity = (v) => {
+    if (typeof v !== "string" || !/^(0x[\da-fA-F]+|\d+)$/.test(v))
+        throw new Error("Invalid audit quantity");
+    return BigInt(v).toString();
+};
+const number = (v) => {
+    const n = typeof v === "number" ? v : Number(quantity(v));
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error("Invalid audit number");
+    return n;
+};
+const block = (v) => {
+    if (!v)
+        throw new Error("Missing audit block");
+    return {
+        number: number(v.number),
+        hash: hash(v.hash),
+        parentHash: hash(v.parentHash),
+    };
+};
+const data = (v) => {
+    if (typeof v !== "string" || !/^0x(?:[\da-fA-F]{2})*$/.test(v))
+        throw new Error("Invalid audit calldata");
+    return v.toLowerCase();
+};
+function txEvidence(tx, receipt) {
+    if (!tx || !receipt)
+        throw new Error("Missing/pending audit transaction or receipt");
+    if (quantity(receipt.status) !== "1")
+        throw new Error("Audit receipt must succeed");
+    return {
+        hash: hash(tx.hash),
+        from: address(tx.from),
+        to: address(tx.to),
+        value: quantity(tx.value),
+        data: data(tx.input),
+        blockNumber: number(tx.blockNumber),
+        blockHash: hash(tx.blockHash),
+        transactionIndex: number(tx.transactionIndex),
+        receipt: {
+            hash: hash(receipt.transactionHash),
+            from: address(receipt.from),
+            to: address(receipt.to),
+            blockNumber: number(receipt.blockNumber),
+            blockHash: hash(receipt.blockHash),
+            transactionIndex: number(receipt.transactionIndex),
+            status: 1,
+        },
+    };
+}
+/** Pure verification of captured local evidence. Never evaluates scripts or reads source business state. */
+function verifyCapturedForkAudit(raw, expected) {
+    const v = (0, canonicalData_1.exactObject)(raw, [
+        "version",
+        "planHash",
+        "chainId",
+        "provider",
+        "sourceSnapshot",
+        "baseline",
+        "end",
+        "blocks",
+        "transactions",
+        "submissions",
+        "completedTransactions",
+        "setup",
+        "evidenceHash",
+    ], "fork audit");
+    const { evidenceHash, ...body } = v;
+    if (v.version !== 1 ||
+        (0, canonicalData_1.digest)(evidenceHash, "fork audit") !== (0, canonicalData_1.semanticHash)(body) ||
+        v.planHash !== expected.planHash ||
+        v.chainId !== expected.chainId ||
+        (0, canonicalData_1.canonicalJson)(v.sourceSnapshot) !== (0, canonicalData_1.canonicalJson)(expected.sourceSnapshot))
+        throw new Error("Fork audit identity mismatch");
+    const provider = (0, canonicalData_1.exactObject)(v.provider, ["kind", "instanceId"], "audit provider");
+    if (provider.kind !== "hardhat")
+        throw new Error("Unsupported audit provider");
+    hash(provider.instanceId);
+    const source = (0, canonicalData_1.exactObject)(v.sourceSnapshot, ["blockNumber", "blockHash"], "source snapshot");
+    number(source.blockNumber);
+    hash(source.blockHash);
+    const baseline = block(v.baseline), end = block(v.end);
+    (0, canonicalData_1.exactObject)(v.baseline, ["number", "hash", "parentHash"], "baseline");
+    (0, canonicalData_1.exactObject)(v.end, ["number", "hash", "parentHash"], "end");
+    if (baseline.number < Number(source.blockNumber) ||
+        end.number < baseline.number)
+        throw new Error("Invalid audit interval");
+    for (const key of [
+        "blocks",
+        "transactions",
+        "submissions",
+        "completedTransactions",
+        "setup",
+    ])
+        if (!Array.isArray(v[key]))
+            throw new Error(`Invalid audit ${key}`);
+    const e = v;
+    let parent = baseline;
+    const hashes = [];
+    for (const raw of e.blocks) {
+        const b = (0, canonicalData_1.exactObject)(raw, ["number", "hash", "parentHash", "transactionHashes"], "audit block");
+        const current = block(b);
+        if (current.number !== parent.number + 1 ||
+            current.parentHash !== parent.hash ||
+            !Array.isArray(b.transactionHashes))
+            throw new Error("Audit block ancestry mismatch");
+        hashes.push(...b.transactionHashes.map(hash));
+        parent = current;
+    }
+    if ((0, canonicalData_1.canonicalJson)(parent) !== (0, canonicalData_1.canonicalJson)(end) ||
+        new Set(hashes).size !== hashes.length ||
+        (0, canonicalData_1.canonicalJson)(hashes) !== (0, canonicalData_1.canonicalJson)(e.transactions.map((t) => t.hash)))
+        throw new Error("Audit interval transaction coverage mismatch");
+    const completed = e.completedTransactions;
+    if ((0, canonicalData_1.canonicalJson)(completed) !==
+        (0, canonicalData_1.canonicalJson)(expected.completedTransactions ?? []))
+        throw new Error("Fork audit completed prefix differs from caller-validated prefix");
+    if (completed.length > expected.transactions.length)
+        throw new Error("Invalid completed audit prefix");
+    const completedHashes = new Set();
+    completed.forEach((c, i) => {
+        (0, canonicalData_1.exactObject)(c, ["transactionId", "transactionHash"], "completed transaction");
+        if (c.transactionId !== expected.transactions[i].transactionId ||
+            completedHashes.has(hash(c.transactionHash)))
+            throw new Error("Invalid completed audit prefix");
+        completedHashes.add(hash(c.transactionHash));
+    });
+    const suffix = expected.transactions.slice(completed.length);
+    if (suffix.length !== e.transactions.length ||
+        e.submissions.length !== suffix.length)
+        throw new Error("Missing or extra/unplanned fork transaction");
+    const seen = new Set();
+    for (const [i, tx] of e.transactions.entries()) {
+        (0, canonicalData_1.exactObject)(tx, [
+            "hash",
+            "from",
+            "to",
+            "value",
+            "data",
+            "blockNumber",
+            "blockHash",
+            "transactionIndex",
+            "receipt",
+        ], "audit transaction");
+        const receipt = (0, canonicalData_1.exactObject)(tx.receipt, [
+            "hash",
+            "from",
+            "to",
+            "blockNumber",
+            "blockHash",
+            "transactionIndex",
+            "status",
+        ], "audit receipt");
+        const canonical = txEvidence({ ...tx, input: tx.data }, {
+            ...receipt,
+            transactionHash: receipt.hash,
+            status: String(receipt.status),
+        });
+        if ((0, canonicalData_1.canonicalJson)(canonical) !== (0, canonicalData_1.canonicalJson)(tx))
+            throw new Error("Noncanonical audit transaction");
+        const b = e.blocks.find((b) => b.number === tx.blockNumber), p = suffix[i], s = e.submissions[i];
+        (0, canonicalData_1.exactObject)(s, ["transactionId", "transactionHash"], "submission");
+        if (!b ||
+            b.hash !== tx.blockHash ||
+            b.transactionHashes[tx.transactionIndex] !== tx.hash ||
+            seen.has(tx.hash) ||
+            completedHashes.has(tx.hash) ||
+            s.transactionId !== p.transactionId ||
+            hash(s.transactionHash) !== tx.hash ||
+            p.operation !== 0 ||
+            p.executor !== tx.from ||
+            p.to !== tx.to ||
+            p.value !== tx.value ||
+            p.data !== tx.data)
+            throw new Error("Fork transaction envelope/order/identity mismatch");
+        seen.add(tx.hash);
+        if (receipt.status !== 1 ||
+            receipt.hash !== tx.hash ||
+            receipt.from !== tx.from ||
+            receipt.to !== tx.to ||
+            receipt.blockNumber !== tx.blockNumber ||
+            receipt.blockHash !== tx.blockHash ||
+            receipt.transactionIndex !== tx.transactionIndex)
+            throw new Error("Fork receipt identity mismatch");
+    }
+    for (const setup of e.setup) {
+        (0, canonicalData_1.exactObject)(setup, [
+            "method",
+            "address",
+            ...(setup.method === "hardhat_setBalance" ? ["value"] : []),
+        ], "trusted setup");
+        address(setup.address);
+        if (!["hardhat_setBalance", "hardhat_impersonateAccount"].includes(setup.method))
+            throw new Error("Invalid trusted setup");
+        if (setup.value !== undefined)
+            quantity(setup.value);
+    }
+    return (0, canonicalData_1.deepFreeze)((0, canonicalData_1.canonicalData)(e));
+}
+/** Guard covers this explicit provider's public request/send boundary. No same-UID isolation claim. */
+class LocalForkAudit {
+    input;
+    baseline;
+    instanceId;
+    scope = new node_async_hooks_1.AsyncLocalStorage();
+    submissions = [];
+    setupObservations = [];
+    violation = false;
+    closed = false;
+    originalRequest;
+    originalSend;
+    guardedRequest;
+    guardedSend;
+    constructor(input, baseline, instanceId) {
+        this.input = input;
+        this.baseline = baseline;
+        this.instanceId = instanceId;
+        const provider = input.provider;
+        this.originalRequest = provider.request;
+        this.originalSend = provider.send;
+        this.guardedRequest = async (args) => {
+            this.guard(args.method, args.params ?? []);
+            return this.originalRequest.call(provider, args);
+        };
+        this.guardedSend = async (method, params = []) => this.guardedRequest({ method, params });
+        try {
+            provider.request = this.guardedRequest;
+            if (provider.send)
+                provider.send = this.guardedSend;
+        }
+        catch (error) {
+            if (provider.request === this.guardedRequest)
+                provider.request = this.originalRequest;
+            if (provider.send === this.guardedSend)
+                provider.send = this.originalSend;
+            throw error;
+        }
+    }
+    static async start(input) {
+        const rpc = (method, params = []) => input.provider.request({ method, params });
+        const [chainId, metadata, latest] = await Promise.all([
+            rpc("eth_chainId"),
+            rpc("hardhat_metadata"),
+            rpc("eth_getBlockByNumber", ["latest", false]),
+        ]);
+        if (quantity(chainId) !== input.chainId ||
+            String(metadata.chainId) !== input.chainId)
+            throw new Error("Fork provider chain identity mismatch");
+        const baseline = block(latest);
+        if (baseline.number < input.sourceSnapshot.blockNumber)
+            throw new Error("Fork baseline precedes source snapshot");
+        const audit = new LocalForkAudit(input, baseline, hash(metadata.instanceId));
+        try {
+            await audit.assertSettled();
+            if ((await audit.rpc("hardhat_getAutomine")) !== true)
+                throw new Error("Fork audit requires automine; manual mining is unsupported");
+            return audit;
+        }
+        catch (error) {
+            audit.close();
+            throw error;
+        }
+    }
+    captured = false;
+    guard(method, params) {
+        if (this.captured && (/^(eth_send|personal_|wallet_|hardhat_|anvil_|evm_)/.test(method)) && !["hardhat_metadata", "hardhat_getAutomine"].includes(method)) {
+            this.violation = true;
+            throw new Error("Fork business ports closed");
+        }
+        const local = /^(hardhat_|anvil_|evm_)/.test(method);
+        const reads = new Set([
+            "hardhat_metadata",
+            "hardhat_getAutomine",
+            "evm_mine",
+            "hardhat_mine",
+        ]);
+        if (!local || reads.has(method))
+            return;
+        const scope = this.scope.getStore();
+        if (scope?.active &&
+            ["hardhat_impersonateAccount", "hardhat_setBalance"].includes(method) &&
+            Array.isArray(params) &&
+            address(params[0]) === scope.address &&
+            params.length === (method === "hardhat_setBalance" ? 2 : 1)) {
+            this.setupObservations.push({
+                method,
+                address: scope.address,
+                ...(method === "hardhat_setBalance"
+                    ? { value: quantity(params[1]) }
+                    : {}),
+            });
+            return;
+        }
+        this.violation = true;
+        throw new Error(`Forbidden fork mutation after baseline: ${method}`);
+    }
+    async setup(executor, action) {
+        if (this.closed || this.captured)
+            throw new Error("Fork audit closed");
+        const scope = { address: address(executor), active: true };
+        return this.scope.run(scope, async () => {
+            try {
+                return await action();
+            }
+            finally {
+                scope.active = false;
+            }
+        });
+    }
+    record(observation) {
+        if (this.closed || this.captured)
+            throw new Error("Fork audit closed");
+        if (this.submissions.some((s) => s.transactionId === observation.transactionId ||
+            s.transactionHash === hash(observation.transactionHash))) {
+            this.violation = true;
+            throw new Error("Duplicate fork submission");
+        }
+        this.submissions.push({
+            transactionId: observation.transactionId,
+            transactionHash: hash(observation.transactionHash),
+        });
+    }
+    rpc(method, params = []) {
+        return this.input.provider.request({ method, params });
+    }
+    async assertSettled() {
+        const [pending, block] = await Promise.all([
+            this.rpc("eth_pendingTransactions"),
+            this.rpc("eth_getBlockByNumber", ["pending", true]),
+        ]);
+        if (!Array.isArray(pending) ||
+            pending.length ||
+            !block ||
+            !Array.isArray(block.transactions) ||
+            block.transactions.length)
+            throw new Error("Pending or unobservable fork transactions");
+    }
+    async finish(input) {
+        return (await this.capture(input)).bind(input.planHash);
+    }
+    /** Owner-held interval. No final plan identity exists until its one-shot pure binding. */
+    async capture(input) {
+        if (this.captured || this.closed)
+            throw new Error('Fork capture closed');
+        this.captured = true;
+        const frozen = (0, canonicalData_1.deepFreeze)((0, canonicalData_1.canonicalData)(input));
+        const placeholder = '0'.repeat(64);
+        const original = await this.readInterval({ ...frozen, planHash: placeholder });
+        const { planHash: _, evidenceHash: __, ...snapshot } = original;
+        let state = 'open';
+        const assertOpen = () => { if (state !== 'open' || this.closed)
+            throw new Error('Captured fork interval closed or bound'); };
+        return Object.freeze({
+            snapshot: (0, canonicalData_1.deepFreeze)(snapshot),
+            assertUnchanged: async () => {
+                assertOpen();
+                try {
+                    if ((0, canonicalData_1.canonicalJson)(await this.readInterval({ ...frozen, planHash: placeholder })) !== (0, canonicalData_1.canonicalJson)(original))
+                        throw new Error('Captured fork interval drift');
+                }
+                catch (error) {
+                    state = 'failed';
+                    throw error;
+                }
+            },
+            bind: (planHash) => {
+                assertOpen();
+                state = 'failed';
+                if (this.violation || this.input.provider.request !== this.guardedRequest || (this.originalSend && this.input.provider.send !== this.guardedSend))
+                    throw new Error('Fork audit provider mutation/identity violation');
+                const { evidenceHash: _, ...body } = original;
+                const bound = { ...body, planHash };
+                const result = verifyCapturedForkAudit({ ...bound, evidenceHash: (0, canonicalData_1.semanticHash)(bound) }, { ...frozen, planHash, chainId: this.input.chainId, sourceSnapshot: this.input.sourceSnapshot });
+                state = 'bound';
+                return result;
+            },
+        });
+    }
+    async readInterval(input) {
+        if (this.closed ||
+            this.violation ||
+            this.input.provider.request !== this.guardedRequest ||
+            (this.originalSend && this.input.provider.send !== this.guardedSend))
+            throw new Error("Fork audit provider mutation/identity violation");
+        await this.assertSettled();
+        const [chainId, metadata, start, last] = await Promise.all([
+            this.rpc("eth_chainId"),
+            this.rpc("hardhat_metadata"),
+            this.rpc("eth_getBlockByNumber", [
+                "0x" + this.baseline.number.toString(16),
+                false,
+            ]),
+            this.rpc("eth_getBlockByNumber", ["latest", false]),
+        ]);
+        if (quantity(chainId) !== this.input.chainId ||
+            hash(metadata.instanceId) !== this.instanceId ||
+            (0, canonicalData_1.canonicalJson)(block(start)) !== (0, canonicalData_1.canonicalJson)(this.baseline))
+            throw new Error("Fork audit baseline/provider identity changed");
+        const end = block(last), blocks = [], transactions = [];
+        for (let n = this.baseline.number + 1; n <= end.number; n++) {
+            const raw = await this.rpc("eth_getBlockByNumber", [
+                "0x" + n.toString(16),
+                true,
+            ]);
+            const b = block(raw);
+            if (!Array.isArray(raw.transactions))
+                throw new Error("Missing full audit block");
+            blocks.push({
+                ...b,
+                transactionHashes: raw.transactions.map((tx) => hash(tx.hash)),
+            });
+            for (const tx of raw.transactions) {
+                const [receipt, lookup] = await Promise.all([
+                    this.rpc("eth_getTransactionReceipt", [tx.hash]),
+                    this.rpc("eth_getTransactionByHash", [tx.hash]),
+                ]);
+                const evidence = txEvidence(tx, receipt);
+                if ((0, canonicalData_1.canonicalJson)(evidence) !== (0, canonicalData_1.canonicalJson)(txEvidence(lookup, receipt)))
+                    throw new Error("Audit transaction lookup mismatch");
+                transactions.push(evidence);
+            }
+        }
+        await this.assertSettled();
+        if ((0, canonicalData_1.canonicalJson)(block(await this.rpc("eth_getBlockByNumber", ["latest", false]))) !== (0, canonicalData_1.canonicalJson)(end))
+            throw new Error("Fork audit changed while enumerating");
+        const body = {
+            version: 1,
+            planHash: input.planHash,
+            chainId: this.input.chainId,
+            provider: { kind: "hardhat", instanceId: this.instanceId },
+            sourceSnapshot: this.input.sourceSnapshot,
+            baseline: this.baseline,
+            end,
+            blocks,
+            transactions,
+            submissions: this.submissions,
+            completedTransactions: input.completedTransactions,
+            setup: this.setupObservations,
+        };
+        return verifyCapturedForkAudit({ ...body, evidenceHash: (0, canonicalData_1.semanticHash)(body) }, {
+            ...input,
+            chainId: this.input.chainId,
+            sourceSnapshot: this.input.sourceSnapshot,
+        });
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.input.provider.request = this.originalRequest;
+        if (this.originalSend)
+            this.input.provider.send = this.originalSend;
+        this.scope.disable();
+    }
+}
+exports.LocalForkAudit = LocalForkAudit;
+//# sourceMappingURL=forkAudit.js.map