gate-evm-tools 1.0.27 → 1.0.31

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

@@ -0,0 +1,188 @@
+import type { HardhatRuntimeEnvironment } from 'hardhat/types';
+import type { GateToolArtifact, GateToolPreparationValidation, GateToolPreparationRequestV1, GateToolPreparationPlanV1 } from 'gate-evm-tools/workflow';
+import { ContractFactory } from 'ethers';
+import { type DeployData } from '@openzeppelin/hardhat-upgrades/dist/utils/deploy-impl';
+import { type CompilerPackage, type CompilerResolution } from './compiler-files';
+import { type SameForkInitialPreparation } from './same-fork-baseline';
+declare const ADAPTER: "hardhat-2.26.3-oz-3.9.1-core-1.44.2-v1";
+type Json = Record<string, any>;
+interface Task {
+    action: Function;
+    parentTaskDefinition?: Task;
+}
+interface Build {
+    compilerPath: string;
+    isSolcJs: boolean;
+    version: string;
+    longVersion: string;
+}
+interface CompilerIdentity {
+    kind: 'npm-soljson-0.8.28' | 'native-macos-0.8.28';
+    version: string;
+    longVersion: string;
+    digest: string;
+    source: string;
+}
+interface Run {
+    input: Json;
+    output: Json;
+    compiler: CompilerIdentity;
+    inputDigest: string;
+    outputDigest: string;
+}
+interface Source {
+    sourceName: string;
+    path: string;
+    digest: string;
+    package: string | null;
+    dependencies: string[];
+    emitsArtifact: boolean;
+}
+interface Job {
+    id: string;
+    config: Json;
+    sources: Source[];
+    runs: Run[];
+    validation: Json;
+}
+interface Artifact {
+    fqn: string;
+    job: string;
+    artifact: GateToolArtifact;
+    digest: string;
+    path: string;
+    contents: string;
+    debugPath: string;
+    debugContents: string;
+    buildInfo: string;
+}
+interface BuildInfoEvidence {
+    path: string;
+    contents: string;
+    digest: string;
+    job: string;
+}
+interface Selection {
+    fqn: string;
+    job: string;
+    artifactDigest: string;
+    unlinkedBytecode: string;
+    linkedBytecode: string;
+    encodedArgs: string;
+    version: Json;
+    layout: Json;
+    validation: Json;
+    options: Json;
+    digest: string;
+}
+type Baseline = {
+    target: string;
+    chainId: number;
+    manifestPolicy: string;
+    selection: string;
+    proxy: Json;
+    currentImplementation: string;
+    implementationKey: string;
+    oldLayout: Json;
+    prior: {
+        stableDigest: string;
+        exactDigest: string;
+        selection: string;
+        qualification: CompilerEvidence;
+    };
+} & ({
+    kind: 'target-manifest';
+    manifestDigest: string;
+    implementationEntry: Json;
+} | {
+    kind: 'same-fork';
+    sameForkBaselineDigest: string;
+    initial: SameForkInitialPreparation;
+});
+type BaselineObservation = NonNullable<Parameters<NonNullable<GateToolPreparationValidation['deployData']>>[0]['baseline']>;
+export interface CompilerEvidence {
+    version: 1;
+    adapter: typeof ADAPTER;
+    toolchain: {
+        node: string;
+        platform: string;
+        arch: string;
+        abi: string;
+        packages: CompilerPackage[];
+        resolutions: CompilerResolution[];
+        modules: Array<{
+            path: string;
+            digest: string;
+        }>;
+    };
+    jobs: Job[];
+    builds: BuildInfoEvidence[];
+    artifacts: Artifact[];
+    selections: Selection[];
+    baselines: Baseline[];
+    stableDigest: string;
+    exactDigest: string;
+}
+export interface DeliveryCompilerOptions {
+    compiler?: {
+        kind: 'npm-soljson-0.8.28' | 'native-macos-0.8.28';
+        path: string;
+    };
+}
+/** Registered only after manifest bootstrap, pinned OZ and the owned proxy-source adapter. */
+export declare function registerDeliveryCompiler(subtask: typeof import('hardhat/config').subtask, tasks: Record<string, Task>, extendEnvironment: typeof import('hardhat/config').extendEnvironment): void;
+declare class CompilerSession {
+    #private;
+    readonly hre: HardhatRuntimeEnvironment;
+    readonly options: DeliveryCompilerOptions;
+    constructor(hre: HardhatRuntimeEnvironment, options: DeliveryCompilerOptions);
+    configIdentity(): string;
+    get compiling(): boolean;
+    assertRegistry(): void;
+    compile(): Promise<void>;
+    graph(graph: any): void;
+    job(args: any, next: (args: any) => Promise<any>): Promise<any>;
+    run(args: any, next: (args: any) => Promise<any>): Promise<any>;
+    build(args: any, next: (args: any) => Promise<any>): Promise<Build>;
+    runner(name: string, args: any, next: (args: any) => Promise<any>): Promise<any>;
+    artifact(name: string, raw: GateToolArtifact): GateToolArtifact;
+    implementation(name: string, constructorArgs: unknown[], options?: Json): Promise<Selection>;
+    observeDeployData(artifact: GateToolArtifact, factory: ContractFactory, data: DeployData, options: Json): Selection;
+    /** Explicit historical source/artifact/constructor selection, never parsed JSON authority. */
+    baseline(implementation: string, handle: DeliveryCompilerCollector, selection: Selection): void;
+    priorQualification(prior: {
+        collector: CompilerSession;
+        selection: Selection;
+    }): Baseline['prior'];
+    captureBaseline(request: GateToolPreparationRequestV1, selection: Selection, observation: BaselineObservation): void;
+    hasSameForkInitial(initial: SameForkInitialPreparation): boolean;
+    verifySameForkUpgrade(target: string, proxy: string, sourceBlock: number | undefined): Promise<void>;
+    readonly sameForkBaseline: NonNullable<GateToolPreparationValidation['sameForkBaseline']>;
+    readonly deployData: NonNullable<GateToolPreparationValidation['deployData']>;
+    preparationSelection(request: Exclude<GateToolPreparationRequestV1, {
+        kind: 'create2-deploy';
+    }>, plan: GateToolPreparationPlanV1): Selection;
+    /** Awaited read-only replay observation. No compile, preparation or DeployData invocation. */
+    observePreparationPlan(request: GateToolPreparationRequestV1, plan: GateToolPreparationPlanV1): Promise<void>;
+    /** Pure expected/disk/reuse check over complete owned baseline observations. */
+    preparationPlan(request: GateToolPreparationRequestV1, plan: GateToolPreparationPlanV1): void;
+    evidence(): CompilerEvidence;
+}
+/** Frozen opaque handle. Parsed records and lookalike objects cannot obtain collector authority. */
+export interface DeliveryCompilerCollector {
+    artifact: CompilerSession['artifact'];
+    implementation: CompilerSession['implementation'];
+    baseline: CompilerSession['baseline'];
+    /** Synchronous full verification. Async owned entry points yield before returning to RPC callers. */
+    evidence: CompilerSession['evidence'];
+    preparationPlan: CompilerSession['preparationPlan'];
+}
+export declare function qualifyDeliveryCompiler(hre: HardhatRuntimeEnvironment, options?: DeliveryCompilerOptions): Promise<DeliveryCompilerCollector>;
+export declare function ownedDeliveryCompiler(hre: object): DeliveryCompilerCollector | undefined;
+/** Internal adapter port, intentionally absent from the public opaque handle. */
+export declare function compilerPreparationHooks(hre: object): Pick<GateToolPreparationValidation, 'deployData' | 'sameForkBaseline'>;
+export declare function hasCompilerSameForkInitial(hre: object, initial: SameForkInitialPreparation): boolean;
+export declare function verifyCompilerSameForkUpgrade(hre: object, target: string, proxy: string, sourceBlock: number | undefined): Promise<void>;
+export declare function validateCompilerPreparationPlan(hre: object, request: GateToolPreparationRequestV1, plan: GateToolPreparationPlanV1): Promise<void>;
+export declare function parseCompilerEvidence(raw: unknown): CompilerEvidence;
+export {};