gate-evm-tools 1.0.28 → 1.0.31

package/runtime/delivery/forkAudit.ts

@@ -0,0 +1,620 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import {
+  canonicalData,
+  canonicalJson,
+  deepFreeze,
+  digest,
+  exactObject,
+  semanticHash,
+} from "../workflow/lib/canonicalData";
+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;
+}
+const hash = (v: unknown): string => {
+  if (typeof v !== "string" || !/^0x[\da-fA-F]{64}$/.test(v))
+    throw new Error("Invalid audit hash");
+  return v.toLowerCase();
+};
+const address = (v: unknown): string => {
+  if (typeof v !== "string" || !/^0x[\da-fA-F]{40}$/.test(v))
+    throw new Error("Invalid audit address");
+  return v.toLowerCase();
+};
+const quantity = (v: unknown): string => {
+  if (typeof v !== "string" || !/^(0x[\da-fA-F]+|\d+)$/.test(v))
+    throw new Error("Invalid audit quantity");
+  return BigInt(v).toString();
+};
+const number = (v: unknown): number => {
+  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: any): BlockIdentity => {
+  if (!v) throw new Error("Missing audit block");
+  return {
+    number: number(v.number),
+    hash: hash(v.hash),
+    parentHash: hash(v.parentHash),
+  };
+};
+const data = (v: unknown): string => {
+  if (typeof v !== "string" || !/^0x(?:[\da-fA-F]{2})*$/.test(v))
+    throw new Error("Invalid audit calldata");
+  return v.toLowerCase();
+};
+function txEvidence(tx: any, receipt: any): TransactionEvidence {
+  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,
+    },
+  };
+}
+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 function verifyCapturedForkAudit(
+  raw: unknown,
+  expected: AuditExpectation,
+): ForkAuditEvidence {
+  const v = 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 ||
+    digest(evidenceHash, "fork audit") !== semanticHash(body) ||
+    v.planHash !== expected.planHash ||
+    v.chainId !== expected.chainId ||
+    canonicalJson(v.sourceSnapshot) !== canonicalJson(expected.sourceSnapshot)
+  )
+    throw new Error("Fork audit identity mismatch");
+  const provider = exactObject(
+    v.provider,
+    ["kind", "instanceId"],
+    "audit provider",
+  );
+  if (provider.kind !== "hardhat")
+    throw new Error("Unsupported audit provider");
+  hash(provider.instanceId);
+  const source = exactObject(
+    v.sourceSnapshot,
+    ["blockNumber", "blockHash"],
+    "source snapshot",
+  );
+  number(source.blockNumber);
+  hash(source.blockHash);
+  const baseline = block(v.baseline),
+    end = block(v.end);
+  exactObject(v.baseline, ["number", "hash", "parentHash"], "baseline");
+  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 as unknown as ForkAuditEvidence;
+  let parent = baseline;
+  const hashes: string[] = [];
+  for (const raw of e.blocks) {
+    const b = 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 (
+    canonicalJson(parent) !== canonicalJson(end) ||
+    new Set(hashes).size !== hashes.length ||
+    canonicalJson(hashes) !== canonicalJson(e.transactions.map((t) => t.hash))
+  )
+    throw new Error("Audit interval transaction coverage mismatch");
+  const completed = e.completedTransactions;
+  if (
+    canonicalJson(completed) !==
+    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<string>();
+  completed.forEach((c, i) => {
+    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<string>();
+  for (const [i, tx] of e.transactions.entries()) {
+    exactObject(
+      tx,
+      [
+        "hash",
+        "from",
+        "to",
+        "value",
+        "data",
+        "blockNumber",
+        "blockHash",
+        "transactionIndex",
+        "receipt",
+      ],
+      "audit transaction",
+    );
+    const receipt = 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 (canonicalJson(canonical) !== 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];
+    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) {
+    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 deepFreeze(canonicalData(e) as ForkAuditEvidence);
+}
+/** Guard covers this explicit provider's public request/send boundary. No same-UID isolation claim. */
+export class LocalForkAudit {
+  private readonly scope = new AsyncLocalStorage<{
+    address: string;
+    active: boolean;
+  }>();
+  private readonly submissions: CompletedExecutionTransaction[] = [];
+  private readonly setupObservations: ForkAuditEvidence["setup"] = [];
+  private violation = false;
+  private closed = false;
+  private readonly originalRequest: AuditProvider["request"];
+  private readonly originalSend?: AuditProvider["send"];
+  private readonly guardedRequest: AuditProvider["request"];
+  private readonly guardedSend: AuditProvider["send"];
+  private constructor(
+    private readonly input: {
+      provider: AuditProvider;
+      chainId: string;
+      sourceSnapshot: { blockNumber: number; blockHash: string };
+    },
+    private readonly baseline: BlockIdentity,
+    private readonly instanceId: string,
+  ) {
+    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: {
+    provider: AuditProvider;
+    chainId: string;
+    sourceSnapshot: { blockNumber: number; blockHash: string };
+  }): Promise<LocalForkAudit> {
+    const rpc = (method: string, params: unknown[] = []) =>
+      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;
+    }
+  }
+  private captured = false;
+  private guard(method: string, params: any): void {
+    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<T>(executor: string, action: () => Promise<T>): Promise<T> {
+    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: CompletedExecutionTransaction): void {
+    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),
+    });
+  }
+  private rpc(method: string, params: unknown[] = []): Promise<any> {
+    return this.input.provider.request({ method, params });
+  }
+  private async assertSettled(): Promise<void> {
+    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: { transactions: readonly ReleaseExecutionTransaction[]; completedTransactions: CompletedExecutionTransaction[]; planHash: string }): Promise<ForkAuditEvidence> {
+    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: { transactions: readonly ReleaseExecutionTransaction[]; completedTransactions: CompletedExecutionTransaction[] }): Promise<CapturedForkInterval> {
+    if (this.captured || this.closed) throw new Error('Fork capture closed');
+    this.captured = true;
+    const frozen = deepFreeze(canonicalData(input)) as unknown as typeof input;
+    const placeholder = '0'.repeat(64);
+    const original = await this.readInterval({...frozen, planHash:placeholder});
+    const {planHash:_,evidenceHash:__,...snapshot}=original;
+    let state:'open'|'bound'|'failed'='open';
+    const assertOpen=()=>{if(state!=='open'||this.closed)throw new Error('Captured fork interval closed or bound');};
+    return Object.freeze({
+      snapshot:deepFreeze(snapshot),
+      assertUnchanged: async () => {
+        assertOpen();
+        try { if(canonicalJson(await this.readInterval({...frozen,planHash:placeholder}))!==canonicalJson(original))throw new Error('Captured fork interval drift'); }
+        catch(error){state='failed';throw error;}
+      },
+      bind: (planHash:string) => {
+        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:semanticHash(bound)}, {...frozen,planHash,chainId:this.input.chainId,sourceSnapshot:this.input.sourceSnapshot});
+        state='bound';return result;
+      },
+    });
+  }
+  private async readInterval(input: {
+    transactions: readonly ReleaseExecutionTransaction[];
+    completedTransactions: CompletedExecutionTransaction[];
+    planHash: string;
+  }): Promise<ForkAuditEvidence> {
+    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 ||
+      canonicalJson(block(start)) !== canonicalJson(this.baseline)
+    )
+      throw new Error("Fork audit baseline/provider identity changed");
+    const end = block(last),
+      blocks: ForkAuditEvidence["blocks"] = [],
+      transactions: TransactionEvidence[] = [];
+    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: any) => 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 (
+          canonicalJson(evidence) !== canonicalJson(txEvidence(lookup, receipt))
+        )
+          throw new Error("Audit transaction lookup mismatch");
+        transactions.push(evidence);
+      }
+    }
+    await this.assertSettled();
+    if (
+      canonicalJson(
+        block(await this.rpc("eth_getBlockByNumber", ["latest", false])),
+      ) !== canonicalJson(end)
+    )
+      throw new Error("Fork audit changed while enumerating");
+    const body = {
+      version: 1 as const,
+      planHash: input.planHash,
+      chainId: this.input.chainId,
+      provider: { kind: "hardhat" as const, 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: semanticHash(body) },
+      {
+        ...input,
+        chainId: this.input.chainId,
+        sourceSnapshot: this.input.sourceSnapshot,
+      },
+    );
+  }
+  close(): void {
+    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();
+  }
+}

package/runtime/delivery/hardhat.ts

@@ -0,0 +1,38 @@
+import { configureDeliveryEnvironment, resolveDeliveryRuntimeNetwork } from './manifest';
+import { parseDeliveryRequest } from './protocol';
+import path from 'node:path';
+import { registerConfigurationEnvironment } from './configuration-hre';
+import { registerOwnedFork } from './aggregate-bootstrap';
+// Retain the dependency's type augmentations in our emitted declaration without an eager runtime import.
+export type { HardhatUpgrades } from '@openzeppelin/hardhat-upgrades';
+
+// Deliberately use require after the pure bootstrap: upgrades-core captures its directory at import.
+const root = process.cwd();
+const request = process.env.GATE_DELIVERY_CONTEXT === undefined ? undefined
+  : parseDeliveryRequest(JSON.parse(process.env.GATE_DELIVERY_CONTEXT));
+const runner = request ? resolveDeliveryRuntimeNetwork({ root, request }) : undefined;
+configureDeliveryEnvironment({ root });
+if (process.env.GATE_DELIVERY_CONTEXT !== undefined
+  && Object.keys(require.cache).some(file => /[/\\]@openzeppelin[/\\]upgrades-core[/\\]/.test(file))) {
+  throw new Error('OpenZeppelin was already loaded before delivery bootstrap; use a fresh process with delivery-hardhat first');
+}
+const { subtask, extendEnvironment, extendConfig } = require('hardhat/config') as typeof import('hardhat/config');
+registerOwnedFork(extendConfig);
+registerConfigurationEnvironment(extendEnvironment);
+// Register before ethers/OZ environment extenders. HRE selects its network after config
+// extenders run, so a static default or CLI inspection alone cannot establish this binding.
+if (runner !== undefined) extendEnvironment(hre => {
+  if (hre.network.name !== runner) throw new Error(`Actual HRE network conflict: expected ${runner}, received ${hre.network.name}`);
+  if (path.resolve(hre.config.paths.root) !== path.resolve(root)
+    || path.resolve(hre.config.paths.configFile) !== path.join(root, 'hardhat.config.ts')) throw new Error('Actual HRE project/config conflict with delivery context');
+});
+require('@nomicfoundation/hardhat-ethers');
+require('@openzeppelin/hardhat-upgrades');
+const { TASK_COMPILE_SOLIDITY_GET_SOURCE_NAMES } = require('hardhat/builtin-tasks/task-names') as typeof import('hardhat/builtin-tasks/task-names');
+const { registerWorkflowDependencyCompiler } = require('../config/hardhatAdapters') as typeof import('../config/hardhatAdapters');
+registerWorkflowDependencyCompiler(subtask, TASK_COMPILE_SOLIDITY_GET_SOURCE_NAMES);
+const compiler = require('./compiler') as typeof import('./compiler');
+const { HardhatContext } = require('hardhat/internal/context') as typeof import('hardhat/internal/context');
+compiler.registerDeliveryCompiler(subtask, HardhatContext.getHardhatContext().tasksDSL.getTaskDefinitions() as any, extendEnvironment);
+export const qualifyDeliveryCompiler = compiler.qualifyDeliveryCompiler;
+export const parseCompilerEvidence = compiler.parseCompilerEvidence;

package/runtime/delivery/history-registration.ts

@@ -0,0 +1,10 @@
+/** Only selected production networks may change an accepted development registration. */
+import {canonicalJson} from '../workflow/lib/canonicalData';
+import {validateContractInfo} from '../workflow/lib/deployments';
+import {validateDeploymentInfo} from '../workflow/lib/deploymentInfo';
+export const historicalRegistrationFile=(file:string)=>file==='contractInfo.json'||file==='deploymentInfo.json';
+export function validateHistoricalRegistration(file:string,baseline:string,current:string,productionTargets:readonly string[]){
+ const keep=(rows:Record<string,unknown>)=>Object.fromEntries(Object.entries(rows).filter(([name])=>!productionTargets.includes(name)));
+ const project=(text:string)=>{const value=JSON.parse(text);return file==='contractInfo.json'?keep(validateContractInfo(value)):{...validateDeploymentInfo(value),networks:keep(validateDeploymentInfo(value).networks)};};
+ if(!historicalRegistrationFile(file)||canonicalJson(project(baseline))!==canonicalJson(project(current)))throw Error(`Historical development registration changed: ${file}`);
+}