@aztec/stdlib 0.0.0-test.0

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

@@ -0,0 +1,2956 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+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.ZodEffects<z.ZodObject<{
+        functionName: z.ZodString;
+        calldata: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+        hints: z.ZodEffects<z.ZodObject<{
+            enqueuedCalls: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                contractAddress: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                calldata: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                contractAddress: import("../aztec-address/index.js").AztecAddress;
+                calldata: import("@aztec/foundation/schemas").Fr[];
+            }, {
+                calldata: string[];
+                contractAddress?: any;
+            }>, import("../avm/avm.js").AvmEnqueuedCallHint, {
+                calldata: string[];
+                contractAddress?: any;
+            }>, "many">;
+            contractInstances: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                address: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                exists: z.ZodBoolean;
+                salt: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                deployer: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                currentContractClassId: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                originalContractClassId: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                initializationHash: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                publicKeys: z.ZodEffects<z.ZodObject<{
+                    masterNullifierPublicKey: z.ZodType<import("@aztec/foundation/schemas").Point, any, string>;
+                    masterIncomingViewingPublicKey: z.ZodType<import("@aztec/foundation/schemas").Point, any, string>;
+                    masterOutgoingViewingPublicKey: z.ZodType<import("@aztec/foundation/schemas").Point, any, string>;
+                    masterTaggingPublicKey: z.ZodType<import("@aztec/foundation/schemas").Point, any, string>;
+                }, "strip", z.ZodTypeAny, {
+                    masterNullifierPublicKey: import("@aztec/foundation/schemas").Point;
+                    masterIncomingViewingPublicKey: import("@aztec/foundation/schemas").Point;
+                    masterOutgoingViewingPublicKey: import("@aztec/foundation/schemas").Point;
+                    masterTaggingPublicKey: import("@aztec/foundation/schemas").Point;
+                }, {
+                    masterNullifierPublicKey: string;
+                    masterIncomingViewingPublicKey: string;
+                    masterOutgoingViewingPublicKey: string;
+                    masterTaggingPublicKey: string;
+                }>, import("../keys/public_keys.js").PublicKeys, {
+                    masterNullifierPublicKey: string;
+                    masterIncomingViewingPublicKey: string;
+                    masterOutgoingViewingPublicKey: string;
+                    masterTaggingPublicKey: string;
+                }>;
+                updateMembershipHint: z.ZodEffects<z.ZodObject<{
+                    leafPreimage: z.ZodEffects<z.ZodObject<{
+                        slot: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                        value: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                        nextSlot: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                        nextIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+                    }, "strip", z.ZodTypeAny, {
+                        value: import("@aztec/foundation/schemas").Fr;
+                        slot: import("@aztec/foundation/schemas").Fr;
+                        nextIndex: bigint;
+                        nextSlot: import("@aztec/foundation/schemas").Fr;
+                    }, {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    }>, import("../trees/public_data_leaf.js").PublicDataTreeLeafPreimage, {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    }>;
+                    leafIndex: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    siblingPath: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    leafPreimage: import("../trees/public_data_leaf.js").PublicDataTreeLeafPreimage;
+                    leafIndex: import("@aztec/foundation/schemas").Fr;
+                    siblingPath: import("@aztec/foundation/schemas").Fr[];
+                }, {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                }>, import("../avm/avm.js").AvmPublicDataReadTreeHint, {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                }>;
+                updatePreimage: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                exists: boolean;
+                address: import("../aztec-address/index.js").AztecAddress;
+                salt: import("@aztec/foundation/schemas").Fr;
+                deployer: import("../aztec-address/index.js").AztecAddress;
+                currentContractClassId: import("@aztec/foundation/schemas").Fr;
+                originalContractClassId: import("@aztec/foundation/schemas").Fr;
+                initializationHash: import("@aztec/foundation/schemas").Fr;
+                publicKeys: import("../keys/public_keys.js").PublicKeys;
+                updateMembershipHint: import("../avm/avm.js").AvmPublicDataReadTreeHint;
+                updatePreimage: import("@aztec/foundation/schemas").Fr[];
+            }, {
+                exists: boolean;
+                salt: string;
+                currentContractClassId: string;
+                originalContractClassId: string;
+                initializationHash: string;
+                publicKeys: {
+                    masterNullifierPublicKey: string;
+                    masterIncomingViewingPublicKey: string;
+                    masterOutgoingViewingPublicKey: string;
+                    masterTaggingPublicKey: string;
+                };
+                updateMembershipHint: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                updatePreimage: string[];
+                address?: any;
+                deployer?: any;
+            }>, import("../avm/avm.js").AvmContractInstanceHint, {
+                exists: boolean;
+                salt: string;
+                currentContractClassId: string;
+                originalContractClassId: string;
+                initializationHash: string;
+                publicKeys: {
+                    masterNullifierPublicKey: string;
+                    masterIncomingViewingPublicKey: string;
+                    masterOutgoingViewingPublicKey: string;
+                    masterTaggingPublicKey: string;
+                };
+                updateMembershipHint: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                updatePreimage: string[];
+                address?: any;
+                deployer?: any;
+            }>, "many">;
+            contractClasses: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                classId: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                exists: z.ZodBoolean;
+                artifactHash: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                privateFunctionsRoot: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                publicBytecodeCommitment: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                packedBytecode: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Buffer, string>, z.ZodEffects<z.ZodObject<{
+                    type: z.ZodLiteral<"Buffer">;
+                    data: z.ZodArray<z.ZodNumber, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    type: "Buffer";
+                    data: number[];
+                }, {
+                    type: "Buffer";
+                    data: number[];
+                }>, Buffer, {
+                    type: "Buffer";
+                    data: number[];
+                }>]>;
+            }, "strip", z.ZodTypeAny, {
+                classId: import("@aztec/foundation/schemas").Fr;
+                exists: boolean;
+                artifactHash: import("@aztec/foundation/schemas").Fr;
+                privateFunctionsRoot: import("@aztec/foundation/schemas").Fr;
+                publicBytecodeCommitment: import("@aztec/foundation/schemas").Fr;
+                packedBytecode: Buffer;
+            }, {
+                classId: string;
+                exists: boolean;
+                artifactHash: string;
+                privateFunctionsRoot: string;
+                publicBytecodeCommitment: string;
+                packedBytecode: string | {
+                    type: "Buffer";
+                    data: number[];
+                };
+            }>, import("../avm/avm.js").AvmContractClassHint, {
+                classId: string;
+                exists: boolean;
+                artifactHash: string;
+                privateFunctionsRoot: string;
+                publicBytecodeCommitment: string;
+                packedBytecode: string | {
+                    type: "Buffer";
+                    data: number[];
+                };
+            }>, "many">;
+            publicDataReads: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                leafPreimage: z.ZodEffects<z.ZodObject<{
+                    slot: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    value: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextSlot: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+                }, "strip", z.ZodTypeAny, {
+                    value: import("@aztec/foundation/schemas").Fr;
+                    slot: import("@aztec/foundation/schemas").Fr;
+                    nextIndex: bigint;
+                    nextSlot: import("@aztec/foundation/schemas").Fr;
+                }, {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                }>, import("../trees/public_data_leaf.js").PublicDataTreeLeafPreimage, {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                }>;
+                leafIndex: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                siblingPath: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                leafPreimage: import("../trees/public_data_leaf.js").PublicDataTreeLeafPreimage;
+                leafIndex: import("@aztec/foundation/schemas").Fr;
+                siblingPath: import("@aztec/foundation/schemas").Fr[];
+            }, {
+                leafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+                leafIndex: string;
+                siblingPath: string[];
+            }>, import("../avm/avm.js").AvmPublicDataReadTreeHint, {
+                leafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+                leafIndex: string;
+                siblingPath: string[];
+            }>, "many">;
+            publicDataWrites: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                lowLeafRead: z.ZodEffects<z.ZodObject<{
+                    leafPreimage: z.ZodEffects<z.ZodObject<{
+                        slot: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                        value: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                        nextSlot: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                        nextIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+                    }, "strip", z.ZodTypeAny, {
+                        value: import("@aztec/foundation/schemas").Fr;
+                        slot: import("@aztec/foundation/schemas").Fr;
+                        nextIndex: bigint;
+                        nextSlot: import("@aztec/foundation/schemas").Fr;
+                    }, {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    }>, import("../trees/public_data_leaf.js").PublicDataTreeLeafPreimage, {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    }>;
+                    leafIndex: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    siblingPath: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    leafPreimage: import("../trees/public_data_leaf.js").PublicDataTreeLeafPreimage;
+                    leafIndex: import("@aztec/foundation/schemas").Fr;
+                    siblingPath: import("@aztec/foundation/schemas").Fr[];
+                }, {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                }>, import("../avm/avm.js").AvmPublicDataReadTreeHint, {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                }>;
+                newLeafPreimage: z.ZodEffects<z.ZodObject<{
+                    slot: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    value: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextSlot: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+                }, "strip", z.ZodTypeAny, {
+                    value: import("@aztec/foundation/schemas").Fr;
+                    slot: import("@aztec/foundation/schemas").Fr;
+                    nextIndex: bigint;
+                    nextSlot: import("@aztec/foundation/schemas").Fr;
+                }, {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                }>, import("../trees/public_data_leaf.js").PublicDataTreeLeafPreimage, {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                }>;
+                insertionPath: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                lowLeafRead: import("../avm/avm.js").AvmPublicDataReadTreeHint;
+                insertionPath: import("@aztec/foundation/schemas").Fr[];
+                newLeafPreimage: import("../trees/public_data_leaf.js").PublicDataTreeLeafPreimage;
+            }, {
+                lowLeafRead: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                insertionPath: string[];
+                newLeafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+            }>, import("../avm/avm.js").AvmPublicDataWriteTreeHint, {
+                lowLeafRead: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                insertionPath: string[];
+                newLeafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+            }>, "many">;
+            nullifierReads: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                lowLeafPreimage: z.ZodEffects<z.ZodObject<{
+                    nullifier: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextNullifier: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+                }, "strip", z.ZodTypeAny, {
+                    nullifier: import("@aztec/foundation/schemas").Fr;
+                    nextNullifier: import("@aztec/foundation/schemas").Fr;
+                    nextIndex: bigint;
+                }, {
+                    nullifier: string;
+                    nextNullifier: string;
+                    nextIndex: string | number | bigint;
+                }>, import("../trees/nullifier_leaf.js").NullifierLeafPreimage, {
+                    nullifier: string;
+                    nextNullifier: string;
+                    nextIndex: string | number | bigint;
+                }>;
+                lowLeafIndex: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                lowLeafSiblingPath: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                lowLeafPreimage: import("../trees/nullifier_leaf.js").NullifierLeafPreimage;
+                lowLeafIndex: import("@aztec/foundation/schemas").Fr;
+                lowLeafSiblingPath: import("@aztec/foundation/schemas").Fr[];
+            }, {
+                lowLeafPreimage: {
+                    nullifier: string;
+                    nextNullifier: string;
+                    nextIndex: string | number | bigint;
+                };
+                lowLeafIndex: string;
+                lowLeafSiblingPath: string[];
+            }>, import("../avm/avm.js").AvmNullifierReadTreeHint, {
+                lowLeafPreimage: {
+                    nullifier: string;
+                    nextNullifier: string;
+                    nextIndex: string | number | bigint;
+                };
+                lowLeafIndex: string;
+                lowLeafSiblingPath: string[];
+            }>, "many">;
+            nullifierWrites: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                lowLeafRead: z.ZodEffects<z.ZodObject<{
+                    lowLeafPreimage: z.ZodEffects<z.ZodObject<{
+                        nullifier: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                        nextNullifier: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                        nextIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+                    }, "strip", z.ZodTypeAny, {
+                        nullifier: import("@aztec/foundation/schemas").Fr;
+                        nextNullifier: import("@aztec/foundation/schemas").Fr;
+                        nextIndex: bigint;
+                    }, {
+                        nullifier: string;
+                        nextNullifier: string;
+                        nextIndex: string | number | bigint;
+                    }>, import("../trees/nullifier_leaf.js").NullifierLeafPreimage, {
+                        nullifier: string;
+                        nextNullifier: string;
+                        nextIndex: string | number | bigint;
+                    }>;
+                    lowLeafIndex: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    lowLeafSiblingPath: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    lowLeafPreimage: import("../trees/nullifier_leaf.js").NullifierLeafPreimage;
+                    lowLeafIndex: import("@aztec/foundation/schemas").Fr;
+                    lowLeafSiblingPath: import("@aztec/foundation/schemas").Fr[];
+                }, {
+                    lowLeafPreimage: {
+                        nullifier: string;
+                        nextNullifier: string;
+                        nextIndex: string | number | bigint;
+                    };
+                    lowLeafIndex: string;
+                    lowLeafSiblingPath: string[];
+                }>, import("../avm/avm.js").AvmNullifierReadTreeHint, {
+                    lowLeafPreimage: {
+                        nullifier: string;
+                        nextNullifier: string;
+                        nextIndex: string | number | bigint;
+                    };
+                    lowLeafIndex: string;
+                    lowLeafSiblingPath: string[];
+                }>;
+                insertionPath: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                lowLeafRead: import("../avm/avm.js").AvmNullifierReadTreeHint;
+                insertionPath: import("@aztec/foundation/schemas").Fr[];
+            }, {
+                lowLeafRead: {
+                    lowLeafPreimage: {
+                        nullifier: string;
+                        nextNullifier: string;
+                        nextIndex: string | number | bigint;
+                    };
+                    lowLeafIndex: string;
+                    lowLeafSiblingPath: string[];
+                };
+                insertionPath: string[];
+            }>, import("../avm/avm.js").AvmNullifierWriteTreeHint, {
+                lowLeafRead: {
+                    lowLeafPreimage: {
+                        nullifier: string;
+                        nextNullifier: string;
+                        nextIndex: string | number | bigint;
+                    };
+                    lowLeafIndex: string;
+                    lowLeafSiblingPath: string[];
+                };
+                insertionPath: string[];
+            }>, "many">;
+            noteHashReads: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                leafIndex: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                value: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                siblingPath: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                value: import("@aztec/foundation/schemas").Fr;
+                leafIndex: import("@aztec/foundation/schemas").Fr;
+                siblingPath: import("@aztec/foundation/schemas").Fr[];
+            }, {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }>, import("../avm/avm.js").AvmAppendTreeHint, {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }>, "many">;
+            noteHashWrites: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                leafIndex: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                value: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                siblingPath: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                value: import("@aztec/foundation/schemas").Fr;
+                leafIndex: import("@aztec/foundation/schemas").Fr;
+                siblingPath: import("@aztec/foundation/schemas").Fr[];
+            }, {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }>, import("../avm/avm.js").AvmAppendTreeHint, {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }>, "many">;
+            l1ToL2MessageReads: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                leafIndex: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                value: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                siblingPath: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                value: import("@aztec/foundation/schemas").Fr;
+                leafIndex: import("@aztec/foundation/schemas").Fr;
+                siblingPath: import("@aztec/foundation/schemas").Fr[];
+            }, {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }>, import("../avm/avm.js").AvmAppendTreeHint, {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            publicDataWrites: import("../avm/avm.js").AvmPublicDataWriteTreeHint[];
+            enqueuedCalls: import("../avm/avm.js").AvmEnqueuedCallHint[];
+            contractInstances: import("../avm/avm.js").AvmContractInstanceHint[];
+            contractClasses: import("../avm/avm.js").AvmContractClassHint[];
+            publicDataReads: import("../avm/avm.js").AvmPublicDataReadTreeHint[];
+            nullifierReads: import("../avm/avm.js").AvmNullifierReadTreeHint[];
+            nullifierWrites: import("../avm/avm.js").AvmNullifierWriteTreeHint[];
+            noteHashReads: import("../avm/avm.js").AvmAppendTreeHint[];
+            noteHashWrites: import("../avm/avm.js").AvmAppendTreeHint[];
+            l1ToL2MessageReads: import("../avm/avm.js").AvmAppendTreeHint[];
+        }, {
+            publicDataWrites: {
+                lowLeafRead: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                insertionPath: string[];
+                newLeafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+            }[];
+            enqueuedCalls: {
+                calldata: string[];
+                contractAddress?: any;
+            }[];
+            contractInstances: {
+                exists: boolean;
+                salt: string;
+                currentContractClassId: string;
+                originalContractClassId: string;
+                initializationHash: string;
+                publicKeys: {
+                    masterNullifierPublicKey: string;
+                    masterIncomingViewingPublicKey: string;
+                    masterOutgoingViewingPublicKey: string;
+                    masterTaggingPublicKey: string;
+                };
+                updateMembershipHint: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                updatePreimage: string[];
+                address?: any;
+                deployer?: any;
+            }[];
+            contractClasses: {
+                classId: string;
+                exists: boolean;
+                artifactHash: string;
+                privateFunctionsRoot: string;
+                publicBytecodeCommitment: string;
+                packedBytecode: string | {
+                    type: "Buffer";
+                    data: number[];
+                };
+            }[];
+            publicDataReads: {
+                leafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            nullifierReads: {
+                lowLeafPreimage: {
+                    nullifier: string;
+                    nextNullifier: string;
+                    nextIndex: string | number | bigint;
+                };
+                lowLeafIndex: string;
+                lowLeafSiblingPath: string[];
+            }[];
+            nullifierWrites: {
+                lowLeafRead: {
+                    lowLeafPreimage: {
+                        nullifier: string;
+                        nextNullifier: string;
+                        nextIndex: string | number | bigint;
+                    };
+                    lowLeafIndex: string;
+                    lowLeafSiblingPath: string[];
+                };
+                insertionPath: string[];
+            }[];
+            noteHashReads: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            noteHashWrites: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            l1ToL2MessageReads: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+        }>, import("../avm/avm.js").AvmExecutionHints, {
+            publicDataWrites: {
+                lowLeafRead: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                insertionPath: string[];
+                newLeafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+            }[];
+            enqueuedCalls: {
+                calldata: string[];
+                contractAddress?: any;
+            }[];
+            contractInstances: {
+                exists: boolean;
+                salt: string;
+                currentContractClassId: string;
+                originalContractClassId: string;
+                initializationHash: string;
+                publicKeys: {
+                    masterNullifierPublicKey: string;
+                    masterIncomingViewingPublicKey: string;
+                    masterOutgoingViewingPublicKey: string;
+                    masterTaggingPublicKey: string;
+                };
+                updateMembershipHint: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                updatePreimage: string[];
+                address?: any;
+                deployer?: any;
+            }[];
+            contractClasses: {
+                classId: string;
+                exists: boolean;
+                artifactHash: string;
+                privateFunctionsRoot: string;
+                publicBytecodeCommitment: string;
+                packedBytecode: string | {
+                    type: "Buffer";
+                    data: number[];
+                };
+            }[];
+            publicDataReads: {
+                leafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            nullifierReads: {
+                lowLeafPreimage: {
+                    nullifier: string;
+                    nextNullifier: string;
+                    nextIndex: string | number | bigint;
+                };
+                lowLeafIndex: string;
+                lowLeafSiblingPath: string[];
+            }[];
+            nullifierWrites: {
+                lowLeafRead: {
+                    lowLeafPreimage: {
+                        nullifier: string;
+                        nextNullifier: string;
+                        nextIndex: string | number | bigint;
+                    };
+                    lowLeafIndex: string;
+                    lowLeafSiblingPath: string[];
+                };
+                insertionPath: string[];
+            }[];
+            noteHashReads: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            noteHashWrites: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            l1ToL2MessageReads: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+        }>;
+        publicInputs: z.ZodEffects<z.ZodObject<{
+            globalVariables: z.ZodEffects<z.ZodObject<{
+                chainId: ZodFor<import("@aztec/foundation/schemas").Fr>;
+                version: ZodFor<import("@aztec/foundation/schemas").Fr>;
+                blockNumber: ZodFor<import("@aztec/foundation/schemas").Fr>;
+                slotNumber: ZodFor<import("@aztec/foundation/schemas").Fr>;
+                timestamp: ZodFor<import("@aztec/foundation/schemas").Fr>;
+                coinbase: ZodFor<import("@aztec/foundation/schemas").EthAddress>;
+                feeRecipient: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                gasFees: z.ZodEffects<z.ZodObject<{
+                    feePerDaGas: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    feePerL2Gas: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                }, "strip", z.ZodTypeAny, {
+                    feePerDaGas: import("@aztec/foundation/schemas").Fr;
+                    feePerL2Gas: import("@aztec/foundation/schemas").Fr;
+                }, {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                }>, import("../gas/gas_fees.js").GasFees, {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                chainId: import("@aztec/foundation/schemas").Fr;
+                version: import("@aztec/foundation/schemas").Fr;
+                blockNumber: import("@aztec/foundation/schemas").Fr;
+                slotNumber: import("@aztec/foundation/schemas").Fr;
+                timestamp: import("@aztec/foundation/schemas").Fr;
+                coinbase: import("@aztec/foundation/schemas").EthAddress;
+                feeRecipient: import("../aztec-address/index.js").AztecAddress;
+                gasFees: import("../gas/gas_fees.js").GasFees;
+            }, {
+                gasFees: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                chainId?: any;
+                version?: any;
+                blockNumber?: any;
+                slotNumber?: any;
+                timestamp?: any;
+                coinbase?: any;
+                feeRecipient?: any;
+            }>, import("../tx/global_variables.js").GlobalVariables, {
+                gasFees: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                chainId?: any;
+                version?: any;
+                blockNumber?: any;
+                slotNumber?: any;
+                timestamp?: any;
+                coinbase?: any;
+                feeRecipient?: any;
+            }>;
+            startTreeSnapshots: z.ZodEffects<z.ZodObject<{
+                l1ToL2MessageTree: z.ZodEffects<z.ZodObject<{
+                    root: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    root: import("@aztec/foundation/schemas").Fr;
+                    nextAvailableLeafIndex: number;
+                }, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>;
+                noteHashTree: z.ZodEffects<z.ZodObject<{
+                    root: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    root: import("@aztec/foundation/schemas").Fr;
+                    nextAvailableLeafIndex: number;
+                }, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>;
+                nullifierTree: z.ZodEffects<z.ZodObject<{
+                    root: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    root: import("@aztec/foundation/schemas").Fr;
+                    nextAvailableLeafIndex: number;
+                }, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>;
+                publicDataTree: z.ZodEffects<z.ZodObject<{
+                    root: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    root: import("@aztec/foundation/schemas").Fr;
+                    nextAvailableLeafIndex: number;
+                }, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                l1ToL2MessageTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+                noteHashTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+                nullifierTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+                publicDataTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+            }, {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            }>, import("../tx/tree_snapshots.js").TreeSnapshots, {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            }>;
+            startGasUsed: z.ZodEffects<z.ZodObject<{
+                daGas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                l2Gas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                daGas: number;
+                l2Gas: number;
+            }, {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            }>, import("../gas/gas.js").Gas, {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            }>;
+            gasSettings: z.ZodEffects<z.ZodObject<{
+                gasLimits: z.ZodEffects<z.ZodObject<{
+                    daGas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                    l2Gas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    daGas: number;
+                    l2Gas: number;
+                }, {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                }>, import("../gas/gas.js").Gas, {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                }>;
+                teardownGasLimits: z.ZodEffects<z.ZodObject<{
+                    daGas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                    l2Gas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    daGas: number;
+                    l2Gas: number;
+                }, {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                }>, import("../gas/gas.js").Gas, {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                }>;
+                maxFeesPerGas: z.ZodEffects<z.ZodObject<{
+                    feePerDaGas: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    feePerL2Gas: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                }, "strip", z.ZodTypeAny, {
+                    feePerDaGas: import("@aztec/foundation/schemas").Fr;
+                    feePerL2Gas: import("@aztec/foundation/schemas").Fr;
+                }, {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                }>, import("../gas/gas_fees.js").GasFees, {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                }>;
+                maxPriorityFeesPerGas: z.ZodEffects<z.ZodObject<{
+                    feePerDaGas: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    feePerL2Gas: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                }, "strip", z.ZodTypeAny, {
+                    feePerDaGas: import("@aztec/foundation/schemas").Fr;
+                    feePerL2Gas: import("@aztec/foundation/schemas").Fr;
+                }, {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                }>, import("../gas/gas_fees.js").GasFees, {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                gasLimits: import("../gas/gas.js").Gas;
+                teardownGasLimits: import("../gas/gas.js").Gas;
+                maxFeesPerGas: import("../gas/gas_fees.js").GasFees;
+                maxPriorityFeesPerGas: import("../gas/gas_fees.js").GasFees;
+            }, {
+                gasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                teardownGasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                maxFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                maxPriorityFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+            }>, import("../gas/gas_settings.js").GasSettings, {
+                gasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                teardownGasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                maxFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                maxPriorityFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+            }>;
+            feePayer: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+            publicSetupCallRequests: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                msgSender: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                contractAddress: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                functionSelector: ZodFor<import("../abi/function_selector.js").FunctionSelector>;
+                isStaticCall: z.ZodBoolean;
+                argsHash: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+            }, "strip", z.ZodTypeAny, {
+                contractAddress: import("../aztec-address/index.js").AztecAddress;
+                msgSender: import("../aztec-address/index.js").AztecAddress;
+                functionSelector: import("../abi/function_selector.js").FunctionSelector;
+                isStaticCall: boolean;
+                argsHash: import("@aztec/foundation/schemas").Fr;
+            }, {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }>, import("../kernel/public_call_request.js").PublicCallRequest, {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }>, "many">;
+            publicAppLogicCallRequests: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                msgSender: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                contractAddress: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                functionSelector: ZodFor<import("../abi/function_selector.js").FunctionSelector>;
+                isStaticCall: z.ZodBoolean;
+                argsHash: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+            }, "strip", z.ZodTypeAny, {
+                contractAddress: import("../aztec-address/index.js").AztecAddress;
+                msgSender: import("../aztec-address/index.js").AztecAddress;
+                functionSelector: import("../abi/function_selector.js").FunctionSelector;
+                isStaticCall: boolean;
+                argsHash: import("@aztec/foundation/schemas").Fr;
+            }, {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }>, import("../kernel/public_call_request.js").PublicCallRequest, {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }>, "many">;
+            publicTeardownCallRequest: z.ZodEffects<z.ZodObject<{
+                msgSender: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                contractAddress: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                functionSelector: ZodFor<import("../abi/function_selector.js").FunctionSelector>;
+                isStaticCall: z.ZodBoolean;
+                argsHash: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+            }, "strip", z.ZodTypeAny, {
+                contractAddress: import("../aztec-address/index.js").AztecAddress;
+                msgSender: import("../aztec-address/index.js").AztecAddress;
+                functionSelector: import("../abi/function_selector.js").FunctionSelector;
+                isStaticCall: boolean;
+                argsHash: import("@aztec/foundation/schemas").Fr;
+            }, {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }>, import("../kernel/public_call_request.js").PublicCallRequest, {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }>;
+            previousNonRevertibleAccumulatedDataArrayLengths: z.ZodEffects<z.ZodObject<{
+                noteHashes: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                nullifiers: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                l2ToL1Msgs: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                noteHashes: number;
+                nullifiers: number;
+                l2ToL1Msgs: number;
+            }, {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            }>, import("../kernel/private_to_avm_accumulated_data.js").PrivateToAvmAccumulatedDataArrayLengths, {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            }>;
+            previousRevertibleAccumulatedDataArrayLengths: z.ZodEffects<z.ZodObject<{
+                noteHashes: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                nullifiers: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                l2ToL1Msgs: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                noteHashes: number;
+                nullifiers: number;
+                l2ToL1Msgs: number;
+            }, {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            }>, import("../kernel/private_to_avm_accumulated_data.js").PrivateToAvmAccumulatedDataArrayLengths, {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            }>;
+            previousNonRevertibleAccumulatedData: z.ZodEffects<z.ZodObject<{
+                noteHashes: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+                nullifiers: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+                l2ToL1Msgs: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                    message: z.ZodEffects<z.ZodObject<{
+                        recipient: z.ZodType<import("@aztec/foundation/schemas").EthAddress, any, string>;
+                        content: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                        counter: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        counter: number;
+                        recipient: import("@aztec/foundation/schemas").EthAddress;
+                        content: import("@aztec/foundation/schemas").Fr;
+                    }, {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    }>, import("../messaging/l2_to_l1_message.js").L2ToL1Message, {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    }>;
+                    contractAddress: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                }, "strip", z.ZodTypeAny, {
+                    message: import("../messaging/l2_to_l1_message.js").L2ToL1Message;
+                    contractAddress: import("../aztec-address/index.js").AztecAddress;
+                }, {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }>, import("../messaging/l2_to_l1_message.js").ScopedL2ToL1Message, {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                noteHashes: import("@aztec/foundation/schemas").Fr[];
+                nullifiers: import("@aztec/foundation/schemas").Fr[];
+                l2ToL1Msgs: import("../messaging/l2_to_l1_message.js").ScopedL2ToL1Message[];
+            }, {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            }>, import("../kernel/private_to_avm_accumulated_data.js").PrivateToAvmAccumulatedData, {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            }>;
+            previousRevertibleAccumulatedData: z.ZodEffects<z.ZodObject<{
+                noteHashes: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+                nullifiers: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+                l2ToL1Msgs: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                    message: z.ZodEffects<z.ZodObject<{
+                        recipient: z.ZodType<import("@aztec/foundation/schemas").EthAddress, any, string>;
+                        content: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                        counter: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        counter: number;
+                        recipient: import("@aztec/foundation/schemas").EthAddress;
+                        content: import("@aztec/foundation/schemas").Fr;
+                    }, {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    }>, import("../messaging/l2_to_l1_message.js").L2ToL1Message, {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    }>;
+                    contractAddress: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                }, "strip", z.ZodTypeAny, {
+                    message: import("../messaging/l2_to_l1_message.js").L2ToL1Message;
+                    contractAddress: import("../aztec-address/index.js").AztecAddress;
+                }, {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }>, import("../messaging/l2_to_l1_message.js").ScopedL2ToL1Message, {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                noteHashes: import("@aztec/foundation/schemas").Fr[];
+                nullifiers: import("@aztec/foundation/schemas").Fr[];
+                l2ToL1Msgs: import("../messaging/l2_to_l1_message.js").ScopedL2ToL1Message[];
+            }, {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            }>, import("../kernel/private_to_avm_accumulated_data.js").PrivateToAvmAccumulatedData, {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            }>;
+            endTreeSnapshots: z.ZodEffects<z.ZodObject<{
+                l1ToL2MessageTree: z.ZodEffects<z.ZodObject<{
+                    root: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    root: import("@aztec/foundation/schemas").Fr;
+                    nextAvailableLeafIndex: number;
+                }, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>;
+                noteHashTree: z.ZodEffects<z.ZodObject<{
+                    root: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    root: import("@aztec/foundation/schemas").Fr;
+                    nextAvailableLeafIndex: number;
+                }, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>;
+                nullifierTree: z.ZodEffects<z.ZodObject<{
+                    root: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    root: import("@aztec/foundation/schemas").Fr;
+                    nextAvailableLeafIndex: number;
+                }, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>;
+                publicDataTree: z.ZodEffects<z.ZodObject<{
+                    root: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    root: import("@aztec/foundation/schemas").Fr;
+                    nextAvailableLeafIndex: number;
+                }, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>, import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot, {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                l1ToL2MessageTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+                noteHashTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+                nullifierTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+                publicDataTree: import("../trees/append_only_tree_snapshot.js").AppendOnlyTreeSnapshot;
+            }, {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            }>, import("../tx/tree_snapshots.js").TreeSnapshots, {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            }>;
+            endGasUsed: z.ZodEffects<z.ZodObject<{
+                daGas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+                l2Gas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                daGas: number;
+                l2Gas: number;
+            }, {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            }>, import("../gas/gas.js").Gas, {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            }>;
+            accumulatedData: z.ZodEffects<z.ZodObject<{
+                noteHashes: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+                nullifiers: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>, "many">;
+                l2ToL1Msgs: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                    message: z.ZodEffects<z.ZodObject<{
+                        recipient: z.ZodType<import("@aztec/foundation/schemas").EthAddress, any, string>;
+                        content: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                        counter: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        counter: number;
+                        recipient: import("@aztec/foundation/schemas").EthAddress;
+                        content: import("@aztec/foundation/schemas").Fr;
+                    }, {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    }>, import("../messaging/l2_to_l1_message.js").L2ToL1Message, {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    }>;
+                    contractAddress: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                }, "strip", z.ZodTypeAny, {
+                    message: import("../messaging/l2_to_l1_message.js").L2ToL1Message;
+                    contractAddress: import("../aztec-address/index.js").AztecAddress;
+                }, {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }>, import("../messaging/l2_to_l1_message.js").ScopedL2ToL1Message, {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }>, "many">;
+                publicLogs: z.ZodArray<ZodFor<import("../logs/public_log.js").PublicLog>, "many">;
+                publicDataWrites: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                    leafSlot: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                    value: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+                }, "strip", z.ZodTypeAny, {
+                    value: import("@aztec/foundation/schemas").Fr;
+                    leafSlot: import("@aztec/foundation/schemas").Fr;
+                }, {
+                    value: string;
+                    leafSlot: string;
+                }>, import("../avm/public_data_write.js").PublicDataWrite, {
+                    value: string;
+                    leafSlot: string;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                noteHashes: import("@aztec/foundation/schemas").Fr[];
+                nullifiers: import("@aztec/foundation/schemas").Fr[];
+                l2ToL1Msgs: import("../messaging/l2_to_l1_message.js").ScopedL2ToL1Message[];
+                publicLogs: import("../logs/public_log.js").PublicLog[];
+                publicDataWrites: import("../avm/public_data_write.js").PublicDataWrite[];
+            }, {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+                publicLogs: any[];
+                publicDataWrites: {
+                    value: string;
+                    leafSlot: string;
+                }[];
+            }>, import("../avm/avm_accumulated_data.js").AvmAccumulatedData, {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+                publicLogs: any[];
+                publicDataWrites: {
+                    value: string;
+                    leafSlot: string;
+                }[];
+            }>;
+            transactionFee: z.ZodType<import("@aztec/foundation/schemas").Fr, any, string>;
+            reverted: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            globalVariables: import("../tx/global_variables.js").GlobalVariables;
+            startTreeSnapshots: import("../tx/tree_snapshots.js").TreeSnapshots;
+            startGasUsed: import("../gas/gas.js").Gas;
+            gasSettings: import("../gas/gas_settings.js").GasSettings;
+            feePayer: import("../aztec-address/index.js").AztecAddress;
+            publicSetupCallRequests: import("../kernel/public_call_request.js").PublicCallRequest[];
+            publicAppLogicCallRequests: import("../kernel/public_call_request.js").PublicCallRequest[];
+            publicTeardownCallRequest: import("../kernel/public_call_request.js").PublicCallRequest;
+            previousNonRevertibleAccumulatedDataArrayLengths: import("../kernel/private_to_avm_accumulated_data.js").PrivateToAvmAccumulatedDataArrayLengths;
+            previousRevertibleAccumulatedDataArrayLengths: import("../kernel/private_to_avm_accumulated_data.js").PrivateToAvmAccumulatedDataArrayLengths;
+            previousNonRevertibleAccumulatedData: import("../kernel/private_to_avm_accumulated_data.js").PrivateToAvmAccumulatedData;
+            previousRevertibleAccumulatedData: import("../kernel/private_to_avm_accumulated_data.js").PrivateToAvmAccumulatedData;
+            endTreeSnapshots: import("../tx/tree_snapshots.js").TreeSnapshots;
+            endGasUsed: import("../gas/gas.js").Gas;
+            accumulatedData: import("../avm/avm_accumulated_data.js").AvmAccumulatedData;
+            transactionFee: import("@aztec/foundation/schemas").Fr;
+            reverted: boolean;
+        }, {
+            globalVariables: {
+                gasFees: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                chainId?: any;
+                version?: any;
+                blockNumber?: any;
+                slotNumber?: any;
+                timestamp?: any;
+                coinbase?: any;
+                feeRecipient?: any;
+            };
+            startTreeSnapshots: {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            startGasUsed: {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            };
+            gasSettings: {
+                gasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                teardownGasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                maxFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                maxPriorityFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+            };
+            publicSetupCallRequests: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }[];
+            publicAppLogicCallRequests: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }[];
+            publicTeardownCallRequest: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            };
+            previousNonRevertibleAccumulatedDataArrayLengths: {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            };
+            previousRevertibleAccumulatedDataArrayLengths: {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            };
+            previousNonRevertibleAccumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            };
+            previousRevertibleAccumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            };
+            endTreeSnapshots: {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            endGasUsed: {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            };
+            accumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+                publicLogs: any[];
+                publicDataWrites: {
+                    value: string;
+                    leafSlot: string;
+                }[];
+            };
+            transactionFee: string;
+            reverted: boolean;
+            feePayer?: any;
+        }>, import("../avm/avm_circuit_public_inputs.js").AvmCircuitPublicInputs, {
+            globalVariables: {
+                gasFees: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                chainId?: any;
+                version?: any;
+                blockNumber?: any;
+                slotNumber?: any;
+                timestamp?: any;
+                coinbase?: any;
+                feeRecipient?: any;
+            };
+            startTreeSnapshots: {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            startGasUsed: {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            };
+            gasSettings: {
+                gasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                teardownGasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                maxFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                maxPriorityFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+            };
+            publicSetupCallRequests: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }[];
+            publicAppLogicCallRequests: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }[];
+            publicTeardownCallRequest: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            };
+            previousNonRevertibleAccumulatedDataArrayLengths: {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            };
+            previousRevertibleAccumulatedDataArrayLengths: {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            };
+            previousNonRevertibleAccumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            };
+            previousRevertibleAccumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            };
+            endTreeSnapshots: {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            endGasUsed: {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            };
+            accumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+                publicLogs: any[];
+                publicDataWrites: {
+                    value: string;
+                    leafSlot: string;
+                }[];
+            };
+            transactionFee: string;
+            reverted: boolean;
+            feePayer?: any;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        calldata: import("@aztec/foundation/schemas").Fr[];
+        functionName: string;
+        hints: import("../avm/avm.js").AvmExecutionHints;
+        publicInputs: import("../avm/avm_circuit_public_inputs.js").AvmCircuitPublicInputs;
+    }, {
+        calldata: string[];
+        functionName: string;
+        hints: {
+            publicDataWrites: {
+                lowLeafRead: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                insertionPath: string[];
+                newLeafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+            }[];
+            enqueuedCalls: {
+                calldata: string[];
+                contractAddress?: any;
+            }[];
+            contractInstances: {
+                exists: boolean;
+                salt: string;
+                currentContractClassId: string;
+                originalContractClassId: string;
+                initializationHash: string;
+                publicKeys: {
+                    masterNullifierPublicKey: string;
+                    masterIncomingViewingPublicKey: string;
+                    masterOutgoingViewingPublicKey: string;
+                    masterTaggingPublicKey: string;
+                };
+                updateMembershipHint: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                updatePreimage: string[];
+                address?: any;
+                deployer?: any;
+            }[];
+            contractClasses: {
+                classId: string;
+                exists: boolean;
+                artifactHash: string;
+                privateFunctionsRoot: string;
+                publicBytecodeCommitment: string;
+                packedBytecode: string | {
+                    type: "Buffer";
+                    data: number[];
+                };
+            }[];
+            publicDataReads: {
+                leafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            nullifierReads: {
+                lowLeafPreimage: {
+                    nullifier: string;
+                    nextNullifier: string;
+                    nextIndex: string | number | bigint;
+                };
+                lowLeafIndex: string;
+                lowLeafSiblingPath: string[];
+            }[];
+            nullifierWrites: {
+                lowLeafRead: {
+                    lowLeafPreimage: {
+                        nullifier: string;
+                        nextNullifier: string;
+                        nextIndex: string | number | bigint;
+                    };
+                    lowLeafIndex: string;
+                    lowLeafSiblingPath: string[];
+                };
+                insertionPath: string[];
+            }[];
+            noteHashReads: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            noteHashWrites: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            l1ToL2MessageReads: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+        };
+        publicInputs: {
+            globalVariables: {
+                gasFees: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                chainId?: any;
+                version?: any;
+                blockNumber?: any;
+                slotNumber?: any;
+                timestamp?: any;
+                coinbase?: any;
+                feeRecipient?: any;
+            };
+            startTreeSnapshots: {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            startGasUsed: {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            };
+            gasSettings: {
+                gasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                teardownGasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                maxFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                maxPriorityFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+            };
+            publicSetupCallRequests: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }[];
+            publicAppLogicCallRequests: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }[];
+            publicTeardownCallRequest: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            };
+            previousNonRevertibleAccumulatedDataArrayLengths: {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            };
+            previousRevertibleAccumulatedDataArrayLengths: {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            };
+            previousNonRevertibleAccumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            };
+            previousRevertibleAccumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            };
+            endTreeSnapshots: {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            endGasUsed: {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            };
+            accumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+                publicLogs: any[];
+                publicDataWrites: {
+                    value: string;
+                    leafSlot: string;
+                }[];
+            };
+            transactionFee: string;
+            reverted: boolean;
+            feePayer?: any;
+        };
+    }>, AvmCircuitInputs, {
+        calldata: string[];
+        functionName: string;
+        hints: {
+            publicDataWrites: {
+                lowLeafRead: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                insertionPath: string[];
+                newLeafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+            }[];
+            enqueuedCalls: {
+                calldata: string[];
+                contractAddress?: any;
+            }[];
+            contractInstances: {
+                exists: boolean;
+                salt: string;
+                currentContractClassId: string;
+                originalContractClassId: string;
+                initializationHash: string;
+                publicKeys: {
+                    masterNullifierPublicKey: string;
+                    masterIncomingViewingPublicKey: string;
+                    masterOutgoingViewingPublicKey: string;
+                    masterTaggingPublicKey: string;
+                };
+                updateMembershipHint: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                updatePreimage: string[];
+                address?: any;
+                deployer?: any;
+            }[];
+            contractClasses: {
+                classId: string;
+                exists: boolean;
+                artifactHash: string;
+                privateFunctionsRoot: string;
+                publicBytecodeCommitment: string;
+                packedBytecode: string | {
+                    type: "Buffer";
+                    data: number[];
+                };
+            }[];
+            publicDataReads: {
+                leafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            nullifierReads: {
+                lowLeafPreimage: {
+                    nullifier: string;
+                    nextNullifier: string;
+                    nextIndex: string | number | bigint;
+                };
+                lowLeafIndex: string;
+                lowLeafSiblingPath: string[];
+            }[];
+            nullifierWrites: {
+                lowLeafRead: {
+                    lowLeafPreimage: {
+                        nullifier: string;
+                        nextNullifier: string;
+                        nextIndex: string | number | bigint;
+                    };
+                    lowLeafIndex: string;
+                    lowLeafSiblingPath: string[];
+                };
+                insertionPath: string[];
+            }[];
+            noteHashReads: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            noteHashWrites: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            l1ToL2MessageReads: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+        };
+        publicInputs: {
+            globalVariables: {
+                gasFees: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                chainId?: any;
+                version?: any;
+                blockNumber?: any;
+                slotNumber?: any;
+                timestamp?: any;
+                coinbase?: any;
+                feeRecipient?: any;
+            };
+            startTreeSnapshots: {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            startGasUsed: {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            };
+            gasSettings: {
+                gasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                teardownGasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                maxFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                maxPriorityFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+            };
+            publicSetupCallRequests: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }[];
+            publicAppLogicCallRequests: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }[];
+            publicTeardownCallRequest: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            };
+            previousNonRevertibleAccumulatedDataArrayLengths: {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            };
+            previousRevertibleAccumulatedDataArrayLengths: {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            };
+            previousNonRevertibleAccumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            };
+            previousRevertibleAccumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            };
+            endTreeSnapshots: {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            endGasUsed: {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            };
+            accumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+                publicLogs: any[];
+                publicDataWrites: {
+                    value: string;
+                    leafSlot: string;
+                }[];
+            };
+            transactionFee: string;
+            reverted: boolean;
+            feePayer?: any;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: ProvingRequestType.PUBLIC_VM;
+    inputs: AvmCircuitInputs;
+}, {
+    type: ProvingRequestType.PUBLIC_VM;
+    inputs: {
+        calldata: string[];
+        functionName: string;
+        hints: {
+            publicDataWrites: {
+                lowLeafRead: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                insertionPath: string[];
+                newLeafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+            }[];
+            enqueuedCalls: {
+                calldata: string[];
+                contractAddress?: any;
+            }[];
+            contractInstances: {
+                exists: boolean;
+                salt: string;
+                currentContractClassId: string;
+                originalContractClassId: string;
+                initializationHash: string;
+                publicKeys: {
+                    masterNullifierPublicKey: string;
+                    masterIncomingViewingPublicKey: string;
+                    masterOutgoingViewingPublicKey: string;
+                    masterTaggingPublicKey: string;
+                };
+                updateMembershipHint: {
+                    leafPreimage: {
+                        value: string;
+                        slot: string;
+                        nextIndex: string | number | bigint;
+                        nextSlot: string;
+                    };
+                    leafIndex: string;
+                    siblingPath: string[];
+                };
+                updatePreimage: string[];
+                address?: any;
+                deployer?: any;
+            }[];
+            contractClasses: {
+                classId: string;
+                exists: boolean;
+                artifactHash: string;
+                privateFunctionsRoot: string;
+                publicBytecodeCommitment: string;
+                packedBytecode: string | {
+                    type: "Buffer";
+                    data: number[];
+                };
+            }[];
+            publicDataReads: {
+                leafPreimage: {
+                    value: string;
+                    slot: string;
+                    nextIndex: string | number | bigint;
+                    nextSlot: string;
+                };
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            nullifierReads: {
+                lowLeafPreimage: {
+                    nullifier: string;
+                    nextNullifier: string;
+                    nextIndex: string | number | bigint;
+                };
+                lowLeafIndex: string;
+                lowLeafSiblingPath: string[];
+            }[];
+            nullifierWrites: {
+                lowLeafRead: {
+                    lowLeafPreimage: {
+                        nullifier: string;
+                        nextNullifier: string;
+                        nextIndex: string | number | bigint;
+                    };
+                    lowLeafIndex: string;
+                    lowLeafSiblingPath: string[];
+                };
+                insertionPath: string[];
+            }[];
+            noteHashReads: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            noteHashWrites: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+            l1ToL2MessageReads: {
+                value: string;
+                leafIndex: string;
+                siblingPath: string[];
+            }[];
+        };
+        publicInputs: {
+            globalVariables: {
+                gasFees: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                chainId?: any;
+                version?: any;
+                blockNumber?: any;
+                slotNumber?: any;
+                timestamp?: any;
+                coinbase?: any;
+                feeRecipient?: any;
+            };
+            startTreeSnapshots: {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            startGasUsed: {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            };
+            gasSettings: {
+                gasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                teardownGasLimits: {
+                    daGas: string | number | bigint;
+                    l2Gas: string | number | bigint;
+                };
+                maxFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+                maxPriorityFeesPerGas: {
+                    feePerDaGas: string;
+                    feePerL2Gas: string;
+                };
+            };
+            publicSetupCallRequests: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }[];
+            publicAppLogicCallRequests: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            }[];
+            publicTeardownCallRequest: {
+                isStaticCall: boolean;
+                argsHash: string;
+                contractAddress?: any;
+                msgSender?: any;
+                functionSelector?: any;
+            };
+            previousNonRevertibleAccumulatedDataArrayLengths: {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            };
+            previousRevertibleAccumulatedDataArrayLengths: {
+                noteHashes: string | number | bigint;
+                nullifiers: string | number | bigint;
+                l2ToL1Msgs: string | number | bigint;
+            };
+            previousNonRevertibleAccumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            };
+            previousRevertibleAccumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+            };
+            endTreeSnapshots: {
+                l1ToL2MessageTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                noteHashTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                nullifierTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+                publicDataTree: {
+                    root: string;
+                    nextAvailableLeafIndex: string | number | bigint;
+                };
+            };
+            endGasUsed: {
+                daGas: string | number | bigint;
+                l2Gas: string | number | bigint;
+            };
+            accumulatedData: {
+                noteHashes: string[];
+                nullifiers: string[];
+                l2ToL1Msgs: {
+                    message: {
+                        counter: number;
+                        recipient: string;
+                        content: string;
+                    };
+                    contractAddress?: any;
+                }[];
+                publicLogs: any[];
+                publicDataWrites: {
+                    value: string;
+                    leafSlot: string;
+                }[];
+            };
+            transactionFee: string;
+            reverted: boolean;
+            feePayer?: any;
+        };
+    };
+}>, 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