gate-evm-tools 1.0.28 → 1.2.0

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

@@ -0,0 +1,582 @@
+import { type EoaExecutionOptions, type EoaHashReferences } from './eoa';
+import type { ReleaseGraphOptions } from './release-graph';
+import type { DeliveryCollection } from './planning';
+import { type FinalizedAnchor } from './production-finalization';
+export { productionChildEnvironment } from './production-environment';
+export interface ProductionOptions extends ReleaseGraphOptions {
+    planKey: string;
+    rev: number;
+    target: string;
+    operator: string;
+    executionId: string;
+}
+export type ProductionCommand = 'prepare' | 'execute' | 'export-calldata' | 'reconcile' | 'verify';
+/** Read the marker before consuming generated output; no missing-file error while pending. */
+export declare function inspectDeliveryProduction(raw: ProductionOptions, command?: ProductionCommand): {
+    status: "pending";
+    input: ProductionOptions;
+    request?: undefined;
+    source?: undefined;
+    release?: undefined;
+    releaseHash?: undefined;
+    target?: undefined;
+    root?: undefined;
+} | {
+    safeTarget?: any;
+    status: "ready";
+    plan: import("./plan").DeliveryPlan;
+    collection: DeliveryCollection;
+    deliveryCalls: readonly import("./public-calldata").DeliveryCall[];
+    operations: any[];
+    finalization: any;
+    releaseHash: any;
+    artifactHash: any;
+    sha256: string;
+    path: string;
+} | {
+    status: "pending";
+};
+/** Instantiate the delivered business operations, never accept replacement operations or parameters. */
+export declare function prepareDeliveryProduction(raw: ProductionOptions): Promise<{
+    safeTarget?: any;
+    status: "ready";
+    plan: import("./plan").DeliveryPlan;
+    collection: DeliveryCollection;
+    deliveryCalls: readonly import("./public-calldata").DeliveryCall[];
+    operations: any[];
+    finalization: any;
+    releaseHash: any;
+    artifactHash: any;
+    sha256: string;
+    path: string;
+} | {
+    status: "pending";
+}>;
+export interface ProductionHostPorts extends Omit<EoaExecutionOptions, 'plan' | 'context'> {
+    finality: EoaExecutionOptions['context']['finality'];
+    assertCurrent(): void;
+}
+/** Explicit commands share validation; only in-process trusted ports can sign or send. */
+export declare function runDeliveryProduction(command: Exclude<ProductionCommand, 'prepare'>, raw: ProductionOptions, host?: ProductionHostPorts, detail?: {
+    unsigned?: unknown;
+    hashes?: EoaHashReferences;
+}): Promise<import("./eoa").EoaExecutionResult | {
+    model: {
+        safeEnvelopes: {
+            schema: string;
+            version: number;
+            status: string;
+            plan: import("./plan").DeliveryPlan;
+            envelope: import("./safe").SafeEnvelope;
+            unsignedExecTransaction: string;
+            unsignedExecReview: import("./calldata-review").CalldataInvocation;
+        }[];
+        safePreparation: string;
+        version: 1;
+        schema: "gate-delivery-export";
+        status: "artifact-delivered";
+        plan: import("./plan").DeliveryPlan;
+        fullRange: {
+            start: number;
+            end: number;
+        };
+        actionableRange: {
+            start: number;
+            end: number;
+        } | null;
+        completed: import("./observations").TransactionObservation[];
+        dependencies: {
+            transactionId: string;
+            after: string[];
+        }[];
+    };
+    json: string;
+    markdown: string;
+} | {
+    deliveryFile: {
+        status: "READY";
+        path: string;
+        sha256: string;
+        size: number;
+        provenance: {
+            path: string;
+            sha256: string;
+        };
+    };
+    status: "artifact-delivered";
+    model: {
+        releaseHash: any;
+        artifactHash: any;
+        safePreparation?: string | undefined;
+        futureSafeEnvelopes?: string | undefined;
+        calldataReview: {
+            version: number;
+            planHash: string;
+            chainId: string;
+            transactions: import("./calldata-review").CalldataTransactionReview[];
+            check: string;
+        };
+        deliveryContext: {
+            operations: any[];
+            preparations: import("./journal").PreparationEntry[];
+        };
+        version: 1;
+        schema: "gate-delivery-export";
+        status: "artifact-delivered";
+        plan: import("./plan").DeliveryPlan;
+        fullRange: {
+            start: number;
+            end: number;
+        };
+        actionableRange: {
+            start: number;
+            end: number;
+        } | null;
+        completed: import("./observations").TransactionObservation[];
+        dependencies: {
+            transactionId: string;
+            after: string[];
+        }[];
+    };
+    json: string;
+} | {
+    export: {
+        deliveryFile: {
+            status: "READY";
+            path: string;
+            sha256: string;
+            size: number;
+            provenance: {
+                path: string;
+                sha256: string;
+            };
+        };
+        status: "artifact-delivered";
+        model: {
+            releaseHash: any;
+            artifactHash: any;
+            safePreparation?: string | undefined;
+            futureSafeEnvelopes?: string | undefined;
+            calldataReview: {
+                version: number;
+                planHash: string;
+                chainId: string;
+                transactions: import("./calldata-review").CalldataTransactionReview[];
+                check: string;
+            };
+            deliveryContext: {
+                operations: any[];
+                preparations: import("./journal").PreparationEntry[];
+            };
+            version: 1;
+            schema: "gate-delivery-export";
+            status: "artifact-delivered";
+            plan: import("./plan").DeliveryPlan;
+            fullRange: {
+                start: number;
+                end: number;
+            };
+            actionableRange: {
+                start: number;
+                end: number;
+            } | null;
+            completed: import("./observations").TransactionObservation[];
+            dependencies: {
+                transactionId: string;
+                after: string[];
+            }[];
+        };
+        json: string;
+    };
+    status: "preparation-required";
+} | {
+    status: string;
+    assertions: {
+        assertionId: string;
+        actual: unknown;
+        expected: import("../workflow/lib/evidencePorts").TypedValue;
+        blockHash: any;
+    }[];
+    acceptance: {
+        status: string;
+        materialization: {
+            intentHash: any;
+            recordPath: string;
+            recordHash: string;
+            manifests: {
+                file: any;
+                hash: string;
+                layoutHash: any;
+                proxy: any;
+                implementation: any;
+            }[];
+        };
+        checkCode: {
+            version: number;
+            executionId: string;
+            planHash: string;
+            target: string;
+            anchor: FinalizedAnchor;
+            rawFile: string;
+            rawHash: string;
+            registryHash: string;
+            metadataHash: string;
+            effectiveHash: string;
+            expected: import("./check-code").ExpectedDevelopmentCode[];
+            artifacts: import("gate-evm-tools/workflow").GateToolArtifactIdentity[];
+        };
+        receiptPath: string;
+        version: number;
+        identity: string;
+        executionId: string;
+        planHash: string;
+        releaseHash: string;
+        artifactHash: string;
+        inputsHash: string;
+        sourceDefinitionHash: string;
+        planRuntimeIdentity: {
+            version: string;
+            digest: string;
+        };
+        finalizer: string;
+        anchor: FinalizedAnchor;
+        preparations: import("./journal").PreparationEntry[];
+        finalized: import("./observations").TransactionObservation[];
+        assertions: unknown[];
+        changes: any[];
+    };
+} | {
+    status: string;
+    error: string;
+} | {
+    status: "pending";
+}>;
+/** Each network is validated independently before one combined immutable JSON is published. */
+export declare function exportProductionCalldata(productions: readonly ProductionOptions[]): Promise<{
+    status: "artifact-delivered";
+    json: string;
+    deliveryFile: {
+        status: "READY";
+        path: string;
+        sha256: string;
+        size: number;
+        provenance: {
+            path: string;
+            sha256: string;
+        };
+    };
+}>;
+export declare function renderProductionExport(ready: Extract<ReturnType<typeof inspectDeliveryProduction>, {
+    status: 'ready';
+}>, exported?: {
+    model: import("./export").DeliveryExportModel;
+    json: string;
+    markdown: string;
+}): {
+    status: "artifact-delivered";
+    model: {
+        releaseHash: any;
+        artifactHash: any;
+        safePreparation?: string | undefined;
+        futureSafeEnvelopes?: string | undefined;
+        calldataReview: {
+            version: number;
+            planHash: string;
+            chainId: string;
+            transactions: import("./calldata-review").CalldataTransactionReview[];
+            check: string;
+        };
+        deliveryContext: {
+            operations: any[];
+            preparations: import("./journal").PreparationEntry[];
+        };
+        version: 1;
+        schema: "gate-delivery-export";
+        status: "artifact-delivered";
+        plan: import("./plan").DeliveryPlan;
+        fullRange: {
+            start: number;
+            end: number;
+        };
+        actionableRange: {
+            start: number;
+            end: number;
+        } | null;
+        completed: import("./observations").TransactionObservation[];
+        dependencies: {
+            transactionId: string;
+            after: string[];
+        }[];
+    };
+    json: string;
+} | {
+    status: "preparation-required";
+    export: {
+        status: "artifact-delivered";
+        model: {
+            releaseHash: any;
+            artifactHash: any;
+            safePreparation?: string | undefined;
+            futureSafeEnvelopes?: string | undefined;
+            calldataReview: {
+                version: number;
+                planHash: string;
+                chainId: string;
+                transactions: import("./calldata-review").CalldataTransactionReview[];
+                check: string;
+            };
+            deliveryContext: {
+                operations: any[];
+                preparations: import("./journal").PreparationEntry[];
+            };
+            version: 1;
+            schema: "gate-delivery-export";
+            status: "artifact-delivered";
+            plan: import("./plan").DeliveryPlan;
+            fullRange: {
+                start: number;
+                end: number;
+            };
+            actionableRange: {
+                start: number;
+                end: number;
+            } | null;
+            completed: import("./observations").TransactionObservation[];
+            dependencies: {
+                transactionId: string;
+                after: string[];
+            }[];
+        };
+        json: string;
+    };
+};
+/** Static config parser only. No HRE, project imports, accounts or signing environment are evaluated. */
+export declare function productionRpc(raw: ProductionOptions, command: ProductionCommand): Readonly<{
+    request(method: string, params: readonly unknown[]): Promise<unknown>;
+}>;
+/** Separate final preparation: policy comes only from the validated release target. No signing/send. */
+export declare function prepareDeliveryProductionSafe(raw: ProductionOptions, host: ProductionHostPorts): Promise<{
+    status: "safe-prepared";
+    envelope: import("./safe").SafeEnvelope;
+} | {
+    status: "pending";
+} | {
+    status: "not-applicable";
+}>;
+export declare function freezeDeliveryProduction(raw: ProductionOptions, host: ProductionHostPorts): Promise<{
+    status: "frozen";
+    releaseHash: any;
+    plan: import("./plan").DeliveryPlan;
+    artifactHash: any;
+    unsigned: import("./execution-model").UnsignedEnvelope;
+} | {
+    status: "pending";
+    export?: undefined;
+    executionId?: undefined;
+    planHash?: undefined;
+} | {
+    status: "complete";
+    export?: undefined;
+    executionId?: undefined;
+    planHash?: undefined;
+} | {
+    status: "external-executor";
+    export: import("./eoa").EoaExecutionResult | {
+        model: {
+            safeEnvelopes: {
+                schema: string;
+                version: number;
+                status: string;
+                plan: import("./plan").DeliveryPlan;
+                envelope: import("./safe").SafeEnvelope;
+                unsignedExecTransaction: string;
+                unsignedExecReview: import("./calldata-review").CalldataInvocation;
+            }[];
+            safePreparation: string;
+            version: 1;
+            schema: "gate-delivery-export";
+            status: "artifact-delivered";
+            plan: import("./plan").DeliveryPlan;
+            fullRange: {
+                start: number;
+                end: number;
+            };
+            actionableRange: {
+                start: number;
+                end: number;
+            } | null;
+            completed: import("./observations").TransactionObservation[];
+            dependencies: {
+                transactionId: string;
+                after: string[];
+            }[];
+        };
+        json: string;
+        markdown: string;
+    } | {
+        deliveryFile: {
+            status: "READY";
+            path: string;
+            sha256: string;
+            size: number;
+            provenance: {
+                path: string;
+                sha256: string;
+            };
+        };
+        status: "artifact-delivered";
+        model: {
+            releaseHash: any;
+            artifactHash: any;
+            safePreparation?: string | undefined;
+            futureSafeEnvelopes?: string | undefined;
+            calldataReview: {
+                version: number;
+                planHash: string;
+                chainId: string;
+                transactions: import("./calldata-review").CalldataTransactionReview[];
+                check: string;
+            };
+            deliveryContext: {
+                operations: any[];
+                preparations: import("./journal").PreparationEntry[];
+            };
+            version: 1;
+            schema: "gate-delivery-export";
+            status: "artifact-delivered";
+            plan: import("./plan").DeliveryPlan;
+            fullRange: {
+                start: number;
+                end: number;
+            };
+            actionableRange: {
+                start: number;
+                end: number;
+            } | null;
+            completed: import("./observations").TransactionObservation[];
+            dependencies: {
+                transactionId: string;
+                after: string[];
+            }[];
+        };
+        json: string;
+    } | {
+        export: {
+            deliveryFile: {
+                status: "READY";
+                path: string;
+                sha256: string;
+                size: number;
+                provenance: {
+                    path: string;
+                    sha256: string;
+                };
+            };
+            status: "artifact-delivered";
+            model: {
+                releaseHash: any;
+                artifactHash: any;
+                safePreparation?: string | undefined;
+                futureSafeEnvelopes?: string | undefined;
+                calldataReview: {
+                    version: number;
+                    planHash: string;
+                    chainId: string;
+                    transactions: import("./calldata-review").CalldataTransactionReview[];
+                    check: string;
+                };
+                deliveryContext: {
+                    operations: any[];
+                    preparations: import("./journal").PreparationEntry[];
+                };
+                version: 1;
+                schema: "gate-delivery-export";
+                status: "artifact-delivered";
+                plan: import("./plan").DeliveryPlan;
+                fullRange: {
+                    start: number;
+                    end: number;
+                };
+                actionableRange: {
+                    start: number;
+                    end: number;
+                } | null;
+                completed: import("./observations").TransactionObservation[];
+                dependencies: {
+                    transactionId: string;
+                    after: string[];
+                }[];
+            };
+            json: string;
+        };
+        status: "preparation-required";
+    } | {
+        status: string;
+        assertions: {
+            assertionId: string;
+            actual: unknown;
+            expected: import("../workflow/lib/evidencePorts").TypedValue;
+            blockHash: any;
+        }[];
+        acceptance: {
+            status: string;
+            materialization: {
+                intentHash: any;
+                recordPath: string;
+                recordHash: string;
+                manifests: {
+                    file: any;
+                    hash: string;
+                    layoutHash: any;
+                    proxy: any;
+                    implementation: any;
+                }[];
+            };
+            checkCode: {
+                version: number;
+                executionId: string;
+                planHash: string;
+                target: string;
+                anchor: FinalizedAnchor;
+                rawFile: string;
+                rawHash: string;
+                registryHash: string;
+                metadataHash: string;
+                effectiveHash: string;
+                expected: import("./check-code").ExpectedDevelopmentCode[];
+                artifacts: import("gate-evm-tools/workflow").GateToolArtifactIdentity[];
+            };
+            receiptPath: string;
+            version: number;
+            identity: string;
+            executionId: string;
+            planHash: string;
+            releaseHash: string;
+            artifactHash: string;
+            inputsHash: string;
+            sourceDefinitionHash: string;
+            planRuntimeIdentity: {
+                version: string;
+                digest: string;
+            };
+            finalizer: string;
+            anchor: FinalizedAnchor;
+            preparations: import("./journal").PreparationEntry[];
+            finalized: import("./observations").TransactionObservation[];
+            assertions: unknown[];
+            changes: any[];
+        };
+    } | {
+        status: string;
+        error: string;
+    } | {
+        status: "pending";
+    };
+    executionId?: undefined;
+    planHash?: undefined;
+} | {
+    status: "reconcile-required";
+    executionId: string;
+    planHash: string;
+    export?: undefined;
+}>;