@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/tx/partial_state_reference.js

@@ -0,0 +1,60 @@
+import { PARTIAL_STATE_REFERENCE_LENGTH } from '@aztec/constants';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+/**
+ * Stores snapshots of trees which are commonly needed by base or merge rollup circuits.
+ */ export class PartialStateReference {
+    noteHashTree;
+    nullifierTree;
+    publicDataTree;
+    constructor(/** Snapshot of the note hash tree. */ noteHashTree, /** Snapshot of the nullifier tree. */ nullifierTree, /** Snapshot of the public data tree. */ publicDataTree){
+        this.noteHashTree = noteHashTree;
+        this.nullifierTree = nullifierTree;
+        this.publicDataTree = publicDataTree;
+    }
+    static get schema() {
+        return z.object({
+            noteHashTree: AppendOnlyTreeSnapshot.schema,
+            nullifierTree: AppendOnlyTreeSnapshot.schema,
+            publicDataTree: AppendOnlyTreeSnapshot.schema
+        }).transform(({ noteHashTree, nullifierTree, publicDataTree })=>new PartialStateReference(noteHashTree, nullifierTree, publicDataTree));
+    }
+    getSize() {
+        return this.noteHashTree.getSize() + this.nullifierTree.getSize() + this.publicDataTree.getSize();
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new PartialStateReference(reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(AppendOnlyTreeSnapshot));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        const noteHashTree = AppendOnlyTreeSnapshot.fromFields(reader);
+        const nullifierTree = AppendOnlyTreeSnapshot.fromFields(reader);
+        const publicDataTree = AppendOnlyTreeSnapshot.fromFields(reader);
+        return new PartialStateReference(noteHashTree, nullifierTree, publicDataTree);
+    }
+    static empty() {
+        return new PartialStateReference(AppendOnlyTreeSnapshot.zero(), AppendOnlyTreeSnapshot.zero(), AppendOnlyTreeSnapshot.zero());
+    }
+    toBuffer() {
+        return serializeToBuffer(this.noteHashTree, this.nullifierTree, this.publicDataTree);
+    }
+    toFields() {
+        const fields = [
+            ...this.noteHashTree.toFields(),
+            ...this.nullifierTree.toFields(),
+            ...this.publicDataTree.toFields()
+        ];
+        if (fields.length !== PARTIAL_STATE_REFERENCE_LENGTH) {
+            throw new Error(`Invalid number of fields for PartialStateReference. Expected ${PARTIAL_STATE_REFERENCE_LENGTH}, got ${fields.length}`);
+        }
+        return fields;
+    }
+    isEmpty() {
+        return this.noteHashTree.isZero() && this.nullifierTree.isZero() && this.publicDataTree.isZero();
+    }
+    equals(other) {
+        return this.noteHashTree.equals(other.noteHashTree) && this.nullifierTree.equals(other.nullifierTree) && this.publicDataTree.equals(other.publicDataTree);
+    }
+}

package/dest/tx/private_execution_result.d.ts

@@ -0,0 +1,182 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { z } from 'zod';
+import { NoteSelector } from '../abi/note_selector.js';
+import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
+import type { IsEmpty } from '../kernel/utils/interfaces.js';
+import { ContractClassLog } from '../logs/contract_class_log.js';
+import { Note } from '../note/note.js';
+import { type ZodFor } from '../schemas/index.js';
+import { PublicExecutionRequest } from './public_execution_request.js';
+/**
+ * The contents of a new note.
+ */
+export declare class NoteAndSlot {
+    /** The note. */
+    note: Note;
+    /** The storage slot of the note. */
+    storageSlot: Fr;
+    /** The note type identifier. */
+    noteTypeId: NoteSelector;
+    constructor(
+    /** The note. */
+    note: Note, 
+    /** The storage slot of the note. */
+    storageSlot: Fr, 
+    /** The note type identifier. */
+    noteTypeId: NoteSelector);
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        note: z.ZodEffects<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[];
+        }>]>, Note, string | {
+            type: "Buffer";
+            data: number[];
+        }>;
+        storageSlot: ZodFor<Fr>;
+        noteTypeId: z.ZodType<NoteSelector, any, string>;
+    }, "strip", z.ZodTypeAny, {
+        storageSlot: Fr;
+        note: Note;
+        noteTypeId: NoteSelector;
+    }, {
+        note: string | {
+            type: "Buffer";
+            data: number[];
+        };
+        noteTypeId: string;
+        storageSlot?: any;
+    }>, NoteAndSlot, {
+        note: string | {
+            type: "Buffer";
+            data: number[];
+        };
+        noteTypeId: string;
+        storageSlot?: any;
+    }>;
+    static from(fields: FieldsOf<NoteAndSlot>): NoteAndSlot;
+    static random(): NoteAndSlot;
+}
+export declare class CountedContractClassLog implements IsEmpty {
+    log: ContractClassLog;
+    counter: number;
+    constructor(log: ContractClassLog, counter: number);
+    static get schema(): ZodFor<CountedContractClassLog>;
+    static from(fields: {
+        log: ContractClassLog;
+        counter: number;
+    }): CountedContractClassLog;
+    isEmpty(): boolean;
+}
+export declare class CountedPublicExecutionRequest {
+    request: PublicExecutionRequest;
+    counter: number;
+    constructor(request: PublicExecutionRequest, counter: number);
+    static get schema(): ZodFor<CountedPublicExecutionRequest>;
+    static from(fields: FieldsOf<CountedPublicExecutionRequest>): CountedPublicExecutionRequest;
+    isEmpty(): boolean;
+    static random(): Promise<CountedPublicExecutionRequest>;
+}
+export declare class PrivateExecutionResult {
+    entrypoint: PrivateCallExecutionResult;
+    /** The first non revertible nullifier, or zero if there was none. */
+    firstNullifier: Fr;
+    constructor(entrypoint: PrivateCallExecutionResult, 
+    /** The first non revertible nullifier, or zero if there was none. */
+    firstNullifier: Fr);
+    static get schema(): ZodFor<PrivateExecutionResult>;
+    static from(fields: FieldsOf<PrivateExecutionResult>): PrivateExecutionResult;
+    static random(nested?: number): Promise<PrivateExecutionResult>;
+}
+/**
+ * The result of executing a call to a private function.
+ */
+export declare class PrivateCallExecutionResult {
+    /** The ACIR bytecode. */
+    acir: Buffer;
+    /** The verification key. */
+    vk: Buffer;
+    /** The partial witness. */
+    partialWitness: Map<number, string>;
+    /** The call stack item. */
+    publicInputs: PrivateCircuitPublicInputs;
+    /** Mapping of note hash to its index in the note hash tree. Used for building hints for note hash read requests. */
+    noteHashLeafIndexMap: Map<bigint, bigint>;
+    /** The notes created in the executed function. */
+    newNotes: NoteAndSlot[];
+    /** Mapping of note hash counter to the counter of its nullifier. */
+    noteHashNullifierCounterMap: Map<number, number>;
+    /** The raw return values of the executed function. */
+    returnValues: Fr[];
+    /** The nested executions. */
+    nestedExecutions: PrivateCallExecutionResult[];
+    /** Enqueued public function execution requests to be picked up by the sequencer. */
+    enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[];
+    /** Public function execution requested for teardown */
+    publicTeardownFunctionCall: PublicExecutionRequest;
+    /**
+     * Contract class logs emitted during execution of this function call.
+     * Note: These are preimages to `contractClassLogsHashes`.
+     */
+    contractClassLogs: CountedContractClassLog[];
+    constructor(
+    /** The ACIR bytecode. */
+    acir: Buffer, 
+    /** The verification key. */
+    vk: Buffer, 
+    /** The partial witness. */
+    partialWitness: Map<number, string>, 
+    /** The call stack item. */
+    publicInputs: PrivateCircuitPublicInputs, 
+    /** Mapping of note hash to its index in the note hash tree. Used for building hints for note hash read requests. */
+    noteHashLeafIndexMap: Map<bigint, bigint>, 
+    /** The notes created in the executed function. */
+    newNotes: NoteAndSlot[], 
+    /** Mapping of note hash counter to the counter of its nullifier. */
+    noteHashNullifierCounterMap: Map<number, number>, 
+    /** The raw return values of the executed function. */
+    returnValues: Fr[], 
+    /** The nested executions. */
+    nestedExecutions: PrivateCallExecutionResult[], 
+    /** Enqueued public function execution requests to be picked up by the sequencer. */
+    enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[], 
+    /** Public function execution requested for teardown */
+    publicTeardownFunctionCall: PublicExecutionRequest, 
+    /**
+     * Contract class logs emitted during execution of this function call.
+     * Note: These are preimages to `contractClassLogsHashes`.
+     */
+    contractClassLogs: CountedContractClassLog[]);
+    static get schema(): ZodFor<PrivateCallExecutionResult>;
+    static from(fields: FieldsOf<PrivateCallExecutionResult>): PrivateCallExecutionResult;
+    static random(nested?: number): Promise<PrivateCallExecutionResult>;
+}
+export declare function collectNoteHashLeafIndexMap(execResult: PrivateExecutionResult): Map<bigint, bigint>;
+export declare function collectNoteHashNullifierCounterMap(execResult: PrivateExecutionResult): Map<number, number>;
+/**
+ * Collect all contract class logs across all nested executions and sorts by counter.
+ * @param execResult - The topmost execution result.
+ * @returns All contract class logs.
+ */
+export declare function collectSortedContractClassLogs(execResult: PrivateExecutionResult): ContractClassLog[];
+/**
+ * Collect all enqueued public function calls across all nested executions.
+ * @param execResult - The topmost execution result.
+ * @returns All enqueued public function calls.
+ */
+export declare function collectEnqueuedPublicFunctionCalls(execResult: PrivateExecutionResult): PublicExecutionRequest[];
+export declare function collectPublicTeardownFunctionCall(execResult: PrivateExecutionResult): PublicExecutionRequest;
+export declare function getFinalMinRevertibleSideEffectCounter(execResult: PrivateExecutionResult): number;
+export declare function collectNested<T>(executionStack: PrivateCallExecutionResult[], extractExecutionItems: (execution: PrivateCallExecutionResult) => T[]): T[];
+//# sourceMappingURL=private_execution_result.d.ts.map

package/dest/tx/private_execution_result.d.ts.map

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

package/dest/tx/private_execution_result.js

@@ -0,0 +1,261 @@
+import { timesParallel } from '@aztec/foundation/collection';
+import { randomBytes, randomInt } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { z } from 'zod';
+import { NoteSelector } from '../abi/note_selector.js';
+import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
+import { sortByCounter } from '../kernel/utils/order_and_comparison.js';
+import { ContractClassLog } from '../logs/contract_class_log.js';
+import { Note } from '../note/note.js';
+import { mapSchema, schemas } from '../schemas/index.js';
+import { PublicExecutionRequest } from './public_execution_request.js';
+/**
+ * The contents of a new note.
+ */ export class NoteAndSlot {
+    note;
+    storageSlot;
+    noteTypeId;
+    constructor(/** The note. */ note, /** The storage slot of the note. */ storageSlot, /** The note type identifier. */ noteTypeId){
+        this.note = note;
+        this.storageSlot = storageSlot;
+        this.noteTypeId = noteTypeId;
+    }
+    static get schema() {
+        return z.object({
+            note: Note.schema,
+            storageSlot: schemas.Fr,
+            noteTypeId: schemas.NoteSelector
+        }).transform(NoteAndSlot.from);
+    }
+    static from(fields) {
+        return new NoteAndSlot(fields.note, fields.storageSlot, fields.noteTypeId);
+    }
+    static random() {
+        return new NoteAndSlot(Note.random(), Fr.random(), NoteSelector.random());
+    }
+}
+export class CountedContractClassLog {
+    log;
+    counter;
+    constructor(log, counter){
+        this.log = log;
+        this.counter = counter;
+    }
+    static get schema() {
+        return z.object({
+            log: ContractClassLog.schema,
+            counter: schemas.Integer
+        }).transform(CountedContractClassLog.from);
+    }
+    static from(fields) {
+        return new CountedContractClassLog(fields.log, fields.counter);
+    }
+    isEmpty() {
+        return this.log.isEmpty() && !this.counter;
+    }
+}
+export class CountedPublicExecutionRequest {
+    request;
+    counter;
+    constructor(request, counter){
+        this.request = request;
+        this.counter = counter;
+    }
+    static get schema() {
+        return z.object({
+            request: PublicExecutionRequest.schema,
+            counter: schemas.Integer
+        }).transform(CountedPublicExecutionRequest.from);
+    }
+    static from(fields) {
+        return new CountedPublicExecutionRequest(fields.request, fields.counter);
+    }
+    isEmpty() {
+        return this.request.isEmpty() && !this.counter;
+    }
+    static async random() {
+        return new CountedPublicExecutionRequest(await PublicExecutionRequest.random(), 0);
+    }
+}
+export class PrivateExecutionResult {
+    entrypoint;
+    firstNullifier;
+    constructor(entrypoint, /** The first non revertible nullifier, or zero if there was none. */ firstNullifier){
+        this.entrypoint = entrypoint;
+        this.firstNullifier = firstNullifier;
+    }
+    static get schema() {
+        return z.object({
+            entrypoint: PrivateCallExecutionResult.schema,
+            firstNullifier: Fr.schema
+        }).transform(PrivateExecutionResult.from);
+    }
+    static from(fields) {
+        return new PrivateExecutionResult(fields.entrypoint, fields.firstNullifier);
+    }
+    static async random(nested = 1) {
+        return new PrivateExecutionResult(await PrivateCallExecutionResult.random(nested), Fr.random());
+    }
+}
+/**
+ * The result of executing a call to a private function.
+ */ export class PrivateCallExecutionResult {
+    acir;
+    vk;
+    partialWitness;
+    publicInputs;
+    noteHashLeafIndexMap;
+    newNotes;
+    noteHashNullifierCounterMap;
+    returnValues;
+    nestedExecutions;
+    enqueuedPublicFunctionCalls;
+    publicTeardownFunctionCall;
+    contractClassLogs;
+    constructor(// Needed for prover
+    /** The ACIR bytecode. */ acir, /** The verification key. */ vk, /** The partial witness. */ partialWitness, // Needed for the verifier (kernel)
+    /** The call stack item. */ publicInputs, /** Mapping of note hash to its index in the note hash tree. Used for building hints for note hash read requests. */ noteHashLeafIndexMap, /** The notes created in the executed function. */ newNotes, /** Mapping of note hash counter to the counter of its nullifier. */ noteHashNullifierCounterMap, /** The raw return values of the executed function. */ returnValues, /** The nested executions. */ nestedExecutions, /** Enqueued public function execution requests to be picked up by the sequencer. */ enqueuedPublicFunctionCalls, /** Public function execution requested for teardown */ publicTeardownFunctionCall, /**
+     * Contract class logs emitted during execution of this function call.
+     * Note: These are preimages to `contractClassLogsHashes`.
+     */ contractClassLogs){
+        this.acir = acir;
+        this.vk = vk;
+        this.partialWitness = partialWitness;
+        this.publicInputs = publicInputs;
+        this.noteHashLeafIndexMap = noteHashLeafIndexMap;
+        this.newNotes = newNotes;
+        this.noteHashNullifierCounterMap = noteHashNullifierCounterMap;
+        this.returnValues = returnValues;
+        this.nestedExecutions = nestedExecutions;
+        this.enqueuedPublicFunctionCalls = enqueuedPublicFunctionCalls;
+        this.publicTeardownFunctionCall = publicTeardownFunctionCall;
+        this.contractClassLogs = contractClassLogs;
+    }
+    static get schema() {
+        return z.object({
+            acir: schemas.Buffer,
+            vk: schemas.Buffer,
+            partialWitness: mapSchema(z.coerce.number(), z.string()),
+            publicInputs: PrivateCircuitPublicInputs.schema,
+            noteHashLeafIndexMap: mapSchema(schemas.BigInt, schemas.BigInt),
+            newNotes: z.array(NoteAndSlot.schema),
+            noteHashNullifierCounterMap: mapSchema(z.coerce.number(), z.number()),
+            returnValues: z.array(schemas.Fr),
+            nestedExecutions: z.array(z.lazy(()=>PrivateCallExecutionResult.schema)),
+            enqueuedPublicFunctionCalls: z.array(CountedPublicExecutionRequest.schema),
+            publicTeardownFunctionCall: PublicExecutionRequest.schema,
+            contractClassLogs: z.array(CountedContractClassLog.schema)
+        }).transform(PrivateCallExecutionResult.from);
+    }
+    static from(fields) {
+        return new PrivateCallExecutionResult(fields.acir, fields.vk, fields.partialWitness, fields.publicInputs, fields.noteHashLeafIndexMap, fields.newNotes, fields.noteHashNullifierCounterMap, fields.returnValues, fields.nestedExecutions, fields.enqueuedPublicFunctionCalls, fields.publicTeardownFunctionCall, fields.contractClassLogs);
+    }
+    static async random(nested = 1) {
+        return new PrivateCallExecutionResult(randomBytes(4), randomBytes(4), new Map([
+            [
+                1,
+                'one'
+            ]
+        ]), PrivateCircuitPublicInputs.empty(), new Map([
+            [
+                1n,
+                1n
+            ]
+        ]), [
+            NoteAndSlot.random()
+        ], new Map([
+            [
+                0,
+                0
+            ]
+        ]), [
+            Fr.random()
+        ], await timesParallel(nested, ()=>PrivateCallExecutionResult.random(0)), [
+            await CountedPublicExecutionRequest.random()
+        ], await PublicExecutionRequest.random(), [
+            new CountedContractClassLog(await ContractClassLog.random(), randomInt(10))
+        ]);
+    }
+}
+export function collectNoteHashLeafIndexMap(execResult) {
+    const accum = new Map();
+    const collectNoteHashLeafIndexMapRecursive = (callResult, accum)=>{
+        callResult.noteHashLeafIndexMap.forEach((value, key)=>accum.set(key, value));
+        callResult.nestedExecutions.forEach((nested)=>collectNoteHashLeafIndexMapRecursive(nested, accum));
+    };
+    collectNoteHashLeafIndexMapRecursive(execResult.entrypoint, accum);
+    return accum;
+}
+export function collectNoteHashNullifierCounterMap(execResult) {
+    const accum = new Map();
+    const collectNoteHashNullifierCounterMapRecursive = (callResult, accum)=>{
+        callResult.noteHashNullifierCounterMap.forEach((value, key)=>accum.set(key, value));
+        callResult.nestedExecutions.forEach((nested)=>collectNoteHashNullifierCounterMapRecursive(nested, accum));
+    };
+    collectNoteHashNullifierCounterMapRecursive(execResult.entrypoint, accum);
+    return accum;
+}
+/**
+ * Collect all contract class logs across all nested executions.
+ * @param execResult - The topmost execution result.
+ * @returns All contract class logs.
+ */ function collectContractClassLogs(execResult) {
+    return [
+        execResult.contractClassLogs,
+        ...execResult.nestedExecutions.flatMap(collectContractClassLogs)
+    ].flat();
+}
+/**
+ * Collect all contract class logs across all nested executions and sorts by counter.
+ * @param execResult - The topmost execution result.
+ * @returns All contract class logs.
+ */ export function collectSortedContractClassLogs(execResult) {
+    const allLogs = collectContractClassLogs(execResult.entrypoint);
+    const sortedLogs = sortByCounter(allLogs);
+    return sortedLogs.map((l)=>l.log);
+}
+function collectEnqueuedCountedPublicExecutionRequests(execResult) {
+    return [
+        ...execResult.enqueuedPublicFunctionCalls,
+        ...execResult.nestedExecutions.flatMap(collectEnqueuedCountedPublicExecutionRequests)
+    ];
+}
+/**
+ * Collect all enqueued public function calls across all nested executions.
+ * @param execResult - The topmost execution result.
+ * @returns All enqueued public function calls.
+ */ export function collectEnqueuedPublicFunctionCalls(execResult) {
+    const countedRequests = collectEnqueuedCountedPublicExecutionRequests(execResult.entrypoint);
+    // without the reverse sort, the logs will be in a queue like fashion which is wrong
+    // as the kernel processes it like a stack, popping items off and pushing them to output
+    return sortByCounter(countedRequests, false).map((r)=>r.request);
+}
+export function collectPublicTeardownFunctionCall(execResult) {
+    const collectPublicTeardownFunctionCallRecursive = (callResult)=>{
+        return [
+            callResult.publicTeardownFunctionCall,
+            ...callResult.nestedExecutions.flatMap(collectPublicTeardownFunctionCallRecursive)
+        ].filter((call)=>!call.isEmpty());
+    };
+    const teardownCalls = collectPublicTeardownFunctionCallRecursive(execResult.entrypoint);
+    if (teardownCalls.length === 1) {
+        return teardownCalls[0];
+    }
+    if (teardownCalls.length > 1) {
+        throw new Error('Multiple public teardown calls detected');
+    }
+    return PublicExecutionRequest.empty();
+}
+export function getFinalMinRevertibleSideEffectCounter(execResult) {
+    const collectFinalMinRevertibleSideEffectCounterRecursive = (callResult)=>{
+        return callResult.nestedExecutions.reduce((counter, exec)=>{
+            const nestedCounter = collectFinalMinRevertibleSideEffectCounterRecursive(exec);
+            return nestedCounter ? nestedCounter : counter;
+        }, callResult.publicInputs.minRevertibleSideEffectCounter.toNumber());
+    };
+    return collectFinalMinRevertibleSideEffectCounterRecursive(execResult.entrypoint);
+}
+export function collectNested(executionStack, extractExecutionItems) {
+    const thisExecutionReads = executionStack.flatMap(extractExecutionItems);
+    return thisExecutionReads.concat(executionStack.flatMap(({ nestedExecutions })=>collectNested(nestedExecutions, extractExecutionItems)));
+}

package/dest/tx/processed_tx.d.ts

@@ -0,0 +1,70 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AvmProvingRequest } from '../avm/avm_proving_request.js';
+import type { PublicDataWrite } from '../avm/public_data_write.js';
+import { RevertCode } from '../avm/revert_code.js';
+import type { SimulationError } from '../errors/simulation_error.js';
+import type { GasUsed } from '../gas/gas_used.js';
+import { CombinedConstantData } from '../kernel/combined_constant_data.js';
+import type { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import type { GlobalVariables } from './global_variables.js';
+import type { Tx } from './tx.js';
+import { TxEffect } from './tx_effect.js';
+import type { TxHash } from './tx_hash.js';
+export declare enum TxExecutionPhase {
+    SETUP = 0,
+    APP_LOGIC = 1,
+    TEARDOWN = 2
+}
+/**
+ * Represents a tx that has been processed by the sequencer public processor,
+ * so its kernel circuit public inputs are filled in.
+ */
+export type ProcessedTx = {
+    /**
+     * Hash of the transaction.
+     */
+    hash: TxHash;
+    /**
+     * Tx.data. The output of the private kernel tail or tail_to_public.
+     */
+    data: PrivateKernelTailCircuitPublicInputs;
+    /**
+     * Proof for the private execution.
+     */
+    clientIvcProof: ClientIvcProof;
+    /**
+     * The request for AVM proving.
+     */
+    avmProvingRequest: AvmProvingRequest | undefined;
+    /**
+     * Combining `TxConstantData` specified by the user, and `GlobalVariables` injected by the sequencer.
+     */
+    constants: CombinedConstantData;
+    /**
+     * Output data of the tx.
+     */
+    txEffect: TxEffect;
+    gasUsed: GasUsed;
+    /**
+     * Reason the tx was reverted.
+     */
+    revertReason: SimulationError | undefined;
+};
+/**
+ * Represents a tx that failed to be processed by the sequencer public processor.
+ */
+export type FailedTx = {
+    /**
+     * The failing transaction.
+     */
+    tx: Tx;
+    /**
+     * The error that caused the tx to fail.
+     */
+    error: Error;
+};
+export declare function makeProcessedTxFromPrivateOnlyTx(tx: Tx, transactionFee: Fr, feePaymentPublicDataWrite: PublicDataWrite, globalVariables: GlobalVariables): Promise<ProcessedTx>;
+export declare function toNumBlobFields(txs: ProcessedTx[]): number;
+export declare function makeProcessedTxFromTxWithPublicCalls(tx: Tx, avmProvingRequest: AvmProvingRequest, gasUsed: GasUsed, revertCode: RevertCode, revertReason: SimulationError | undefined): Promise<ProcessedTx>;
+//# sourceMappingURL=processed_tx.d.ts.map

package/dest/tx/processed_tx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processed_tx.d.ts","sourceRoot":"","sources":["../../src/tx/processed_tx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,wDAAwD,CAAC;AACnH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,oBAAY,gBAAgB;IAC1B,KAAK,IAAA;IACL,SAAS,IAAA;IACT,QAAQ,IAAA;CACT;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,IAAI,EAAE,oCAAoC,CAAC;IAC3C;;OAEG;IACH,cAAc,EAAE,cAAc,CAAC;IAC/B;;OAEG;IACH,iBAAiB,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACjD;;OAEG;IACH,SAAS,EAAE,oBAAoB,CAAC;IAChC;;OAEG;IACH,QAAQ,EAAE,QAAQ,CAAC;IAInB,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,YAAY,EAAE,eAAe,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB;;OAEG;IACH,EAAE,EAAE,EAAE,CAAC;IACP;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF,wBAAsB,gCAAgC,CACpD,EAAE,EAAE,EAAE,EACN,cAAc,EAAE,EAAE,EAClB,yBAAyB,EAAE,eAAe,EAC1C,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,WAAW,CAAC,CAqCtB;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,MAAM,CAI1D;AAED,wBAAsB,oCAAoC,CACxD,EAAE,EAAE,EAAE,EACN,iBAAiB,EAAE,iBAAiB,EACpC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,eAAe,GAAG,SAAS,GACxC,OAAO,CAAC,WAAW,CAAC,CA0CtB"}

package/dest/tx/processed_tx.js

@@ -0,0 +1,64 @@
+import { RevertCode } from '../avm/revert_code.js';
+import { Gas } from '../gas/gas.js';
+import { siloL2ToL1Message } from '../hash/hash.js';
+import { CombinedConstantData } from '../kernel/combined_constant_data.js';
+import { TxEffect } from './tx_effect.js';
+export var TxExecutionPhase = /*#__PURE__*/ function(TxExecutionPhase) {
+    TxExecutionPhase[TxExecutionPhase["SETUP"] = 0] = "SETUP";
+    TxExecutionPhase[TxExecutionPhase["APP_LOGIC"] = 1] = "APP_LOGIC";
+    TxExecutionPhase[TxExecutionPhase["TEARDOWN"] = 2] = "TEARDOWN";
+    return TxExecutionPhase;
+}({});
+export async function makeProcessedTxFromPrivateOnlyTx(tx, transactionFee, feePaymentPublicDataWrite, globalVariables) {
+    const constants = CombinedConstantData.combine(tx.data.constants, globalVariables);
+    const data = tx.data.forRollup;
+    const txEffect = new TxEffect(RevertCode.OK, await tx.getTxHash(), transactionFee, data.end.noteHashes.filter((h)=>!h.isZero()), data.end.nullifiers.filter((h)=>!h.isZero()), data.end.l2ToL1Msgs.map((message)=>siloL2ToL1Message(message, constants.txContext.version, constants.txContext.chainId)).filter((h)=>!h.isZero()), [
+        feePaymentPublicDataWrite
+    ], data.end.privateLogs.filter((l)=>!l.isEmpty()), [], await tx.filterContractClassLogs(tx.data.getNonEmptyContractClassLogsHashes(), true));
+    const gasUsed = {
+        // Billed gas is the same as total gas since there is no teardown execution
+        totalGas: tx.data.gasUsed,
+        billedGas: tx.data.gasUsed,
+        teardownGas: Gas.empty(),
+        publicGas: Gas.empty()
+    };
+    return {
+        hash: txEffect.txHash,
+        data: tx.data,
+        clientIvcProof: tx.clientIvcProof,
+        avmProvingRequest: undefined,
+        constants,
+        txEffect,
+        gasUsed,
+        revertReason: undefined
+    };
+}
+export function toNumBlobFields(txs) {
+    return txs.reduce((acc, tx)=>{
+        return acc + tx.txEffect.toBlobFields().length;
+    }, 0);
+}
+export async function makeProcessedTxFromTxWithPublicCalls(tx, avmProvingRequest, gasUsed, revertCode, revertReason) {
+    const avmPublicInputs = avmProvingRequest.inputs.publicInputs;
+    const constants = CombinedConstantData.combine(tx.data.constants, avmPublicInputs.globalVariables);
+    const publicDataWrites = avmPublicInputs.accumulatedData.publicDataWrites.filter((w)=>!w.isEmpty());
+    const privateLogs = [
+        ...tx.data.forPublic.nonRevertibleAccumulatedData.privateLogs,
+        ...revertCode.isOK() ? tx.data.forPublic.revertibleAccumulatedData.privateLogs : []
+    ].filter((l)=>!l.isEmpty());
+    const contractClassLogs = [
+        ...await tx.getSplitContractClassLogs(false, true),
+        ...revertCode.isOK() ? await tx.getSplitContractClassLogs(true, true) : []
+    ].filter((l)=>!l.isEmpty());
+    const txEffect = new TxEffect(revertCode, await tx.getTxHash(), avmPublicInputs.transactionFee, avmPublicInputs.accumulatedData.noteHashes.filter((h)=>!h.isZero()), avmPublicInputs.accumulatedData.nullifiers.filter((h)=>!h.isZero()), avmPublicInputs.accumulatedData.l2ToL1Msgs.map((message)=>siloL2ToL1Message(message, constants.txContext.version, constants.txContext.chainId)).filter((h)=>!h.isZero()), publicDataWrites, privateLogs, avmPublicInputs.accumulatedData.publicLogs.filter((l)=>!l.isEmpty()), contractClassLogs);
+    return {
+        hash: txEffect.txHash,
+        data: tx.data,
+        clientIvcProof: tx.clientIvcProof,
+        avmProvingRequest,
+        constants,
+        txEffect,
+        gasUsed,
+        revertReason
+    };
+}