@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/interfaces/proving-job.d.ts

@@ -0,0 +1,391 @@
+import { AVM_PROOF_LENGTH_IN_FIELDS, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, TUBE_PROOF_LENGTH } from '@aztec/constants';
+import type { ZodFor } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+import { AvmCircuitInputs } from '../avm/avm.js';
+import { BaseParityInputs } from '../parity/base_parity_inputs.js';
+import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
+import { RootParityInputs } from '../parity/root_parity_inputs.js';
+import { ProvingRequestType } from '../proofs/proving_request_type.js';
+import { RecursiveProof } from '../proofs/recursive_proof.js';
+import { BaseOrMergeRollupPublicInputs } from '../rollup/base_or_merge_rollup_public_inputs.js';
+import { BlockMergeRollupInputs } from '../rollup/block_merge_rollup.js';
+import { BlockRootOrBlockMergePublicInputs } from '../rollup/block_root_or_block_merge_public_inputs.js';
+import { BlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '../rollup/block_root_rollup.js';
+import { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_inputs.js';
+import { MergeRollupInputs } from '../rollup/merge_rollup.js';
+import { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
+import { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
+import { RootRollupInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
+import { TubeInputs } from '../rollup/tube_inputs.js';
+import type { ServerCircuitName } from '../stats/index.js';
+import { VerificationKeyData } from '../vks/verification_key.js';
+export type ProofAndVerificationKey<N extends number> = {
+    proof: RecursiveProof<N>;
+    verificationKey: VerificationKeyData;
+};
+export declare function makeProofAndVerificationKey<N extends number>(proof: RecursiveProof<N>, verificationKey: VerificationKeyData): ProofAndVerificationKey<N>;
+export type PublicInputsAndRecursiveProof<T, N extends number = typeof NESTED_RECURSIVE_PROOF_LENGTH> = {
+    inputs: T;
+    proof: RecursiveProof<N>;
+    verificationKey: VerificationKeyData;
+};
+export declare function makePublicInputsAndRecursiveProof<T, N extends number = typeof NESTED_RECURSIVE_PROOF_LENGTH>(inputs: T, proof: RecursiveProof<N>, verificationKey: VerificationKeyData): PublicInputsAndRecursiveProof<T, N>;
+export declare function mapProvingRequestTypeToCircuitName(type: ProvingRequestType): ServerCircuitName;
+export declare const ProvingJobInputs: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.PUBLIC_VM>;
+    inputs: z.ZodType<AvmCircuitInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.PUBLIC_VM;
+    inputs: AvmCircuitInputs;
+}, {
+    type: ProvingRequestType.PUBLIC_VM;
+    inputs: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.BASE_PARITY>;
+    inputs: z.ZodType<BaseParityInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.BASE_PARITY;
+    inputs: BaseParityInputs;
+}, {
+    type: ProvingRequestType.BASE_PARITY;
+    inputs: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.ROOT_PARITY>;
+    inputs: z.ZodType<RootParityInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.ROOT_PARITY;
+    inputs: RootParityInputs;
+}, {
+    type: ProvingRequestType.ROOT_PARITY;
+    inputs: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.PRIVATE_BASE_ROLLUP>;
+    inputs: z.ZodType<PrivateBaseRollupInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.PRIVATE_BASE_ROLLUP;
+    inputs: PrivateBaseRollupInputs;
+}, {
+    type: ProvingRequestType.PRIVATE_BASE_ROLLUP;
+    inputs: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.PUBLIC_BASE_ROLLUP>;
+    inputs: z.ZodType<PublicBaseRollupInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.PUBLIC_BASE_ROLLUP;
+    inputs: PublicBaseRollupInputs;
+}, {
+    type: ProvingRequestType.PUBLIC_BASE_ROLLUP;
+    inputs: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.MERGE_ROLLUP>;
+    inputs: z.ZodType<MergeRollupInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.MERGE_ROLLUP;
+    inputs: MergeRollupInputs;
+}, {
+    type: ProvingRequestType.MERGE_ROLLUP;
+    inputs: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.BLOCK_ROOT_ROLLUP>;
+    inputs: z.ZodType<BlockRootRollupInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.BLOCK_ROOT_ROLLUP;
+    inputs: BlockRootRollupInputs;
+}, {
+    type: ProvingRequestType.BLOCK_ROOT_ROLLUP;
+    inputs: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP>;
+    inputs: z.ZodType<SingleTxBlockRootRollupInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP;
+    inputs: SingleTxBlockRootRollupInputs;
+}, {
+    type: ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP;
+    inputs: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP>;
+    inputs: z.ZodType<EmptyBlockRootRollupInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP;
+    inputs: EmptyBlockRootRollupInputs;
+}, {
+    type: ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP;
+    inputs: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.BLOCK_MERGE_ROLLUP>;
+    inputs: z.ZodType<BlockMergeRollupInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.BLOCK_MERGE_ROLLUP;
+    inputs: BlockMergeRollupInputs;
+}, {
+    type: ProvingRequestType.BLOCK_MERGE_ROLLUP;
+    inputs: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.ROOT_ROLLUP>;
+    inputs: z.ZodType<RootRollupInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.ROOT_ROLLUP;
+    inputs: RootRollupInputs;
+}, {
+    type: ProvingRequestType.ROOT_ROLLUP;
+    inputs: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.TUBE_PROOF>;
+    inputs: z.ZodType<TubeInputs, any, string>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.TUBE_PROOF;
+    inputs: TubeInputs;
+}, {
+    type: ProvingRequestType.TUBE_PROOF;
+    inputs: string;
+}>]>;
+export declare function getProvingJobInputClassFor(type: ProvingRequestType): typeof AvmCircuitInputs | typeof BaseParityInputs | typeof RootParityInputs | typeof BlockMergeRollupInputs | typeof BlockRootRollupInputs | typeof SingleTxBlockRootRollupInputs | typeof EmptyBlockRootRollupInputs | typeof MergeRollupInputs | typeof PrivateBaseRollupInputs | typeof PublicBaseRollupInputs | typeof RootRollupInputs | typeof TubeInputs;
+export type ProvingJobInputs = z.infer<typeof ProvingJobInputs>;
+export type ProvingJobInputsMap = {
+    [ProvingRequestType.PUBLIC_VM]: AvmCircuitInputs;
+    [ProvingRequestType.PRIVATE_BASE_ROLLUP]: PrivateBaseRollupInputs;
+    [ProvingRequestType.PUBLIC_BASE_ROLLUP]: PublicBaseRollupInputs;
+    [ProvingRequestType.MERGE_ROLLUP]: MergeRollupInputs;
+    [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: EmptyBlockRootRollupInputs;
+    [ProvingRequestType.BLOCK_ROOT_ROLLUP]: BlockRootRollupInputs;
+    [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: SingleTxBlockRootRollupInputs;
+    [ProvingRequestType.BLOCK_MERGE_ROLLUP]: BlockMergeRollupInputs;
+    [ProvingRequestType.ROOT_ROLLUP]: RootRollupInputs;
+    [ProvingRequestType.BASE_PARITY]: BaseParityInputs;
+    [ProvingRequestType.ROOT_PARITY]: RootParityInputs;
+    [ProvingRequestType.TUBE_PROOF]: TubeInputs;
+};
+export declare const ProvingJobResult: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.PUBLIC_VM>;
+    result: ZodFor<ProofAndVerificationKey<4154>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.PUBLIC_VM;
+    result: ProofAndVerificationKey<4154>;
+}, {
+    type: ProvingRequestType.PUBLIC_VM;
+    result?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.PRIVATE_BASE_ROLLUP>;
+    result: ZodFor<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, 538>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.PRIVATE_BASE_ROLLUP;
+    result: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, 538>;
+}, {
+    type: ProvingRequestType.PRIVATE_BASE_ROLLUP;
+    result?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.PUBLIC_BASE_ROLLUP>;
+    result: ZodFor<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, 538>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.PUBLIC_BASE_ROLLUP;
+    result: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, 538>;
+}, {
+    type: ProvingRequestType.PUBLIC_BASE_ROLLUP;
+    result?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.MERGE_ROLLUP>;
+    result: ZodFor<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, 538>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.MERGE_ROLLUP;
+    result: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, 538>;
+}, {
+    type: ProvingRequestType.MERGE_ROLLUP;
+    result?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP>;
+    result: ZodFor<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, 538>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP;
+    result: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, 538>;
+}, {
+    type: ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP;
+    result?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.BLOCK_ROOT_ROLLUP>;
+    result: ZodFor<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, 538>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.BLOCK_ROOT_ROLLUP;
+    result: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, 538>;
+}, {
+    type: ProvingRequestType.BLOCK_ROOT_ROLLUP;
+    result?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP>;
+    result: ZodFor<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, 538>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP;
+    result: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, 538>;
+}, {
+    type: ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP;
+    result?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.BLOCK_MERGE_ROLLUP>;
+    result: ZodFor<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, 538>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.BLOCK_MERGE_ROLLUP;
+    result: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, 538>;
+}, {
+    type: ProvingRequestType.BLOCK_MERGE_ROLLUP;
+    result?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.ROOT_ROLLUP>;
+    result: ZodFor<PublicInputsAndRecursiveProof<RootRollupPublicInputs, 459>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.ROOT_ROLLUP;
+    result: PublicInputsAndRecursiveProof<RootRollupPublicInputs, 459>;
+}, {
+    type: ProvingRequestType.ROOT_ROLLUP;
+    result?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.BASE_PARITY>;
+    result: ZodFor<PublicInputsAndRecursiveProof<ParityPublicInputs, 459>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.BASE_PARITY;
+    result: PublicInputsAndRecursiveProof<ParityPublicInputs, 459>;
+}, {
+    type: ProvingRequestType.BASE_PARITY;
+    result?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.ROOT_PARITY>;
+    result: ZodFor<PublicInputsAndRecursiveProof<ParityPublicInputs, 459>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.ROOT_PARITY;
+    result: PublicInputsAndRecursiveProof<ParityPublicInputs, 459>;
+}, {
+    type: ProvingRequestType.ROOT_PARITY;
+    result?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ProvingRequestType.TUBE_PROOF>;
+    result: ZodFor<ProofAndVerificationKey<538>>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.TUBE_PROOF;
+    result: ProofAndVerificationKey<538>;
+}, {
+    type: ProvingRequestType.TUBE_PROOF;
+    result?: any;
+}>]>;
+export type ProvingJobResult = z.infer<typeof ProvingJobResult>;
+export type ProvingJobResultsMap = {
+    [ProvingRequestType.PUBLIC_VM]: ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>;
+    [ProvingRequestType.PRIVATE_BASE_ROLLUP]: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
+    [ProvingRequestType.PUBLIC_BASE_ROLLUP]: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
+    [ProvingRequestType.MERGE_ROLLUP]: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
+    [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
+    [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
+    [ProvingRequestType.BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
+    [ProvingRequestType.BLOCK_MERGE_ROLLUP]: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
+    [ProvingRequestType.ROOT_ROLLUP]: PublicInputsAndRecursiveProof<RootRollupPublicInputs>;
+    [ProvingRequestType.BASE_PARITY]: PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>;
+    [ProvingRequestType.ROOT_PARITY]: PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>;
+    [ProvingRequestType.TUBE_PROOF]: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>;
+};
+export type ProvingRequestResultFor<T extends ProvingRequestType> = {
+    type: T;
+    result: ProvingJobResultsMap[T];
+};
+export declare const ProvingJobId: z.ZodString;
+export declare const ProofUri: z.ZodBranded<z.ZodString, "ProvingJobUri">;
+export type ProofUri = z.infer<typeof ProofUri>;
+export type ProvingJobId = z.infer<typeof ProvingJobId>;
+export declare const ProvingJob: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodNativeEnum<typeof ProvingRequestType>;
+    epochNumber: z.ZodNumber;
+    inputsUri: z.ZodBranded<z.ZodString, "ProvingJobUri">;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType;
+    id: string;
+    epochNumber: number;
+    inputsUri: string & z.BRAND<"ProvingJobUri">;
+}, {
+    type: ProvingRequestType;
+    id: string;
+    epochNumber: number;
+    inputsUri: string;
+}>;
+export declare const makeProvingJobId: (epochNumber: number, type: ProvingRequestType, inputsHash: string) => string;
+export declare const getEpochFromProvingJobId: (id: ProvingJobId) => number;
+export type ProvingJob = z.infer<typeof ProvingJob>;
+export declare function makeProvingRequestResult(type: ProvingRequestType, result: ProvingJobResult['result']): ProvingJobResult;
+export declare const ProvingJobFulfilledResult: z.ZodObject<{
+    status: z.ZodLiteral<"fulfilled">;
+    value: z.ZodBranded<z.ZodString, "ProvingJobUri">;
+}, "strip", z.ZodTypeAny, {
+    status: "fulfilled";
+    value: string & z.BRAND<"ProvingJobUri">;
+}, {
+    status: "fulfilled";
+    value: string;
+}>;
+export type ProvingJobFulfilledResult = z.infer<typeof ProvingJobFulfilledResult>;
+export declare const ProvingJobRejectedResult: z.ZodObject<{
+    status: z.ZodLiteral<"rejected">;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "rejected";
+    reason: string;
+}, {
+    status: "rejected";
+    reason: string;
+}>;
+export type ProvingJobRejectedResult = z.infer<typeof ProvingJobRejectedResult>;
+export declare const ProvingJobSettledResult: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+    status: z.ZodLiteral<"fulfilled">;
+    value: z.ZodBranded<z.ZodString, "ProvingJobUri">;
+}, "strip", z.ZodTypeAny, {
+    status: "fulfilled";
+    value: string & z.BRAND<"ProvingJobUri">;
+}, {
+    status: "fulfilled";
+    value: string;
+}>, z.ZodObject<{
+    status: z.ZodLiteral<"rejected">;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "rejected";
+    reason: string;
+}, {
+    status: "rejected";
+    reason: string;
+}>]>;
+export type ProvingJobSettledResult = z.infer<typeof ProvingJobSettledResult>;
+export declare const ProvingJobStatus: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+    status: z.ZodLiteral<"in-queue">;
+}, "strip", z.ZodTypeAny, {
+    status: "in-queue";
+}, {
+    status: "in-queue";
+}>, z.ZodObject<{
+    status: z.ZodLiteral<"in-progress">;
+}, "strip", z.ZodTypeAny, {
+    status: "in-progress";
+}, {
+    status: "in-progress";
+}>, z.ZodObject<{
+    status: z.ZodLiteral<"not-found">;
+}, "strip", z.ZodTypeAny, {
+    status: "not-found";
+}, {
+    status: "not-found";
+}>, z.ZodObject<{
+    status: z.ZodLiteral<"fulfilled">;
+    value: z.ZodBranded<z.ZodString, "ProvingJobUri">;
+}, "strip", z.ZodTypeAny, {
+    status: "fulfilled";
+    value: string & z.BRAND<"ProvingJobUri">;
+}, {
+    status: "fulfilled";
+    value: string;
+}>, z.ZodObject<{
+    status: z.ZodLiteral<"rejected">;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "rejected";
+    reason: string;
+}, {
+    status: "rejected";
+    reason: string;
+}>]>;
+export type ProvingJobStatus = z.infer<typeof ProvingJobStatus>;
+//# sourceMappingURL=proving-job.d.ts.map

package/dest/interfaces/proving-job.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proving-job.d.ts","sourceRoot":"","sources":["../../src/interfaces/proving-job.ts"],"names":[],"mappings":"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"}

package/dest/interfaces/proving-job.js

@@ -0,0 +1,259 @@
+import { AVM_PROOF_LENGTH_IN_FIELDS, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, TUBE_PROOF_LENGTH } from '@aztec/constants';
+import { z } from 'zod';
+import { AvmCircuitInputs } from '../avm/avm.js';
+import { AvmProvingRequestSchema } from '../avm/avm_proving_request.js';
+import { BaseParityInputs } from '../parity/base_parity_inputs.js';
+import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
+import { RootParityInputs } from '../parity/root_parity_inputs.js';
+import { ProvingRequestType } from '../proofs/proving_request_type.js';
+import { RecursiveProof } from '../proofs/recursive_proof.js';
+import { BaseOrMergeRollupPublicInputs } from '../rollup/base_or_merge_rollup_public_inputs.js';
+import { BlockMergeRollupInputs } from '../rollup/block_merge_rollup.js';
+import { BlockRootOrBlockMergePublicInputs } from '../rollup/block_root_or_block_merge_public_inputs.js';
+import { BlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '../rollup/block_root_rollup.js';
+import { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_inputs.js';
+import { MergeRollupInputs } from '../rollup/merge_rollup.js';
+import { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
+import { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
+import { RootRollupInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
+import { TubeInputs } from '../rollup/tube_inputs.js';
+import { VerificationKeyData } from '../vks/verification_key.js';
+function schemaForRecursiveProofAndVerificationKey(proofLength) {
+    return z.object({
+        proof: RecursiveProof.schemaFor(proofLength),
+        verificationKey: VerificationKeyData.schema
+    });
+}
+export function makeProofAndVerificationKey(proof, verificationKey) {
+    return {
+        proof,
+        verificationKey
+    };
+}
+function schemaForPublicInputsAndRecursiveProof(inputs, proofSize) {
+    return z.object({
+        inputs,
+        proof: RecursiveProof.schemaFor(proofSize),
+        verificationKey: VerificationKeyData.schema
+    });
+}
+export function makePublicInputsAndRecursiveProof(inputs, proof, verificationKey) {
+    return {
+        inputs,
+        proof,
+        verificationKey
+    };
+}
+export function mapProvingRequestTypeToCircuitName(type) {
+    switch(type){
+        case ProvingRequestType.PUBLIC_VM:
+            return 'avm-circuit';
+        case ProvingRequestType.PRIVATE_BASE_ROLLUP:
+            return 'private-base-rollup';
+        case ProvingRequestType.PUBLIC_BASE_ROLLUP:
+            return 'public-base-rollup';
+        case ProvingRequestType.MERGE_ROLLUP:
+            return 'merge-rollup';
+        case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP:
+            return 'empty-block-root-rollup';
+        case ProvingRequestType.BLOCK_ROOT_ROLLUP:
+            return 'block-root-rollup';
+        case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP:
+            return 'single-tx-block-root-rollup';
+        case ProvingRequestType.BLOCK_MERGE_ROLLUP:
+            return 'block-merge-rollup';
+        case ProvingRequestType.ROOT_ROLLUP:
+            return 'root-rollup';
+        case ProvingRequestType.BASE_PARITY:
+            return 'base-parity';
+        case ProvingRequestType.ROOT_PARITY:
+            return 'root-parity';
+        case ProvingRequestType.TUBE_PROOF:
+            return 'tube-circuit';
+        default:
+            {
+                const _exhaustive = type;
+                throw new Error(`Cannot find circuit name for proving request type: ${type}`);
+            }
+    }
+}
+export const ProvingJobInputs = z.discriminatedUnion('type', [
+    AvmProvingRequestSchema,
+    z.object({
+        type: z.literal(ProvingRequestType.BASE_PARITY),
+        inputs: BaseParityInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.ROOT_PARITY),
+        inputs: RootParityInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.PRIVATE_BASE_ROLLUP),
+        inputs: PrivateBaseRollupInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.PUBLIC_BASE_ROLLUP),
+        inputs: PublicBaseRollupInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.MERGE_ROLLUP),
+        inputs: MergeRollupInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP),
+        inputs: BlockRootRollupInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP),
+        inputs: SingleTxBlockRootRollupInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP),
+        inputs: EmptyBlockRootRollupInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.BLOCK_MERGE_ROLLUP),
+        inputs: BlockMergeRollupInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.ROOT_ROLLUP),
+        inputs: RootRollupInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.TUBE_PROOF),
+        inputs: TubeInputs.schema
+    })
+]);
+export function getProvingJobInputClassFor(type) {
+    switch(type){
+        case ProvingRequestType.PUBLIC_VM:
+            return AvmCircuitInputs;
+        case ProvingRequestType.PRIVATE_BASE_ROLLUP:
+            return PrivateBaseRollupInputs;
+        case ProvingRequestType.PUBLIC_BASE_ROLLUP:
+            return PublicBaseRollupInputs;
+        case ProvingRequestType.MERGE_ROLLUP:
+            return MergeRollupInputs;
+        case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP:
+            return EmptyBlockRootRollupInputs;
+        case ProvingRequestType.BLOCK_ROOT_ROLLUP:
+            return BlockRootRollupInputs;
+        case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP:
+            return SingleTxBlockRootRollupInputs;
+        case ProvingRequestType.BLOCK_MERGE_ROLLUP:
+            return BlockMergeRollupInputs;
+        case ProvingRequestType.ROOT_ROLLUP:
+            return RootRollupInputs;
+        case ProvingRequestType.BASE_PARITY:
+            return BaseParityInputs;
+        case ProvingRequestType.ROOT_PARITY:
+            return RootParityInputs;
+        case ProvingRequestType.TUBE_PROOF:
+            return TubeInputs;
+        default:
+            {
+                const _exhaustive = type;
+                throw new Error(`Cannot find circuit inputs class for proving type ${type}`);
+            }
+    }
+}
+export const ProvingJobResult = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal(ProvingRequestType.PUBLIC_VM),
+        result: schemaForRecursiveProofAndVerificationKey(AVM_PROOF_LENGTH_IN_FIELDS)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.PRIVATE_BASE_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(BaseOrMergeRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.PUBLIC_BASE_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(BaseOrMergeRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.MERGE_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(BaseOrMergeRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(BlockRootOrBlockMergePublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(BlockRootOrBlockMergePublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(BlockRootOrBlockMergePublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.BLOCK_MERGE_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(BlockRootOrBlockMergePublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.ROOT_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(RootRollupPublicInputs.schema, NESTED_RECURSIVE_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.BASE_PARITY),
+        result: schemaForPublicInputsAndRecursiveProof(ParityPublicInputs.schema, RECURSIVE_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.ROOT_PARITY),
+        result: schemaForPublicInputsAndRecursiveProof(ParityPublicInputs.schema, NESTED_RECURSIVE_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.TUBE_PROOF),
+        result: schemaForRecursiveProofAndVerificationKey(TUBE_PROOF_LENGTH)
+    })
+]);
+export const ProvingJobId = z.string();
+export const ProofUri = z.string().brand('ProvingJobUri');
+export const ProvingJob = z.object({
+    id: ProvingJobId,
+    type: z.nativeEnum(ProvingRequestType),
+    epochNumber: z.number(),
+    inputsUri: ProofUri
+});
+export const makeProvingJobId = (epochNumber, type, inputsHash)=>{
+    return `${epochNumber}:${ProvingRequestType[type]}:${inputsHash}`;
+};
+export const getEpochFromProvingJobId = (id)=>{
+    const components = id.split(':');
+    const epochNumber = components.length < 1 ? Number.NaN : parseInt(components[0], 10);
+    if (!Number.isSafeInteger(epochNumber) || epochNumber < 0) {
+        throw new Error(`Proving Job ID ${id} does not contain valid epoch`);
+    }
+    return epochNumber;
+};
+export function makeProvingRequestResult(type, result) {
+    return {
+        type,
+        result
+    };
+}
+export const ProvingJobFulfilledResult = z.object({
+    status: z.literal('fulfilled'),
+    value: ProofUri
+});
+export const ProvingJobRejectedResult = z.object({
+    status: z.literal('rejected'),
+    reason: z.string()
+});
+export const ProvingJobSettledResult = z.discriminatedUnion('status', [
+    ProvingJobFulfilledResult,
+    ProvingJobRejectedResult
+]);
+export const ProvingJobStatus = z.discriminatedUnion('status', [
+    z.object({
+        status: z.literal('in-queue')
+    }),
+    z.object({
+        status: z.literal('in-progress')
+    }),
+    z.object({
+        status: z.literal('not-found')
+    }),
+    ProvingJobFulfilledResult,
+    ProvingJobRejectedResult
+]);