@aztec/stdlib 0.0.0-test.0 → 0.0.1-commit.0208eb9

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

@@ -1 +1 @@
-{"version":3,"file":"simulated_tx.d.ts","sourceRoot":"","sources":["../../src/tx/simulated_tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EACL,KAAK,gCAAgC,EAEtC,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAAE,oCAAoC,EAAE,MAAM,wDAAwD,CAAC;AAC9G,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAEL,sBAAsB,EAIvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAClG,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B,qBAAa,uBAAuB;IAEzB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;gBADlD,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC;IAG3D,sBAAsB;IAItB,aAAa,IAAI,EAAE;CAcpB;AAED,qBAAa,kBAAmB,SAAQ,uBAAuB;IAIpD,YAAY,CAAC;IACb,aAAa,CAAC;;;;;;gBAHrB,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAC3C,YAAY,CAAC,oCAAwB,EACrC,aAAa,CAAC;;;;;iBAAkC;IAKzD,IAAI,OAAO,IAAI,OAAO,CASrB;IAED,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,kBAAkB,CAAC,CAS9C;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,CAAC;IASjE,qBAAqB;IAIrB,MAAM,CAAC,0CAA0C,CAC/C,uBAAuB,EAAE,uBAAuB,EAChD,YAAY,CAAC,EAAE,sBAAsB,EACrC,aAAa,CAAC,EAAE,gCAAgC;WAUrC,MAAM;CAOpB;AAED,qBAAa,eAAe;IAEjB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;IAClD,cAAc,EAAE,cAAc;gBAF9B,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAClD,cAAc,EAAE,cAAc;IAGvC,IAAI,IAAI,EAAE;IAeV,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;OAQhB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC;WAIhC,MAAM;CAOpB;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,eAAe,EAAE,sBAAsB,GAAG,yBAAyB,CAWhH"}
+{"version":3,"file":"simulated_tx.d.ts","sourceRoot":"","sources":["../../src/tx/simulated_tx.ts"],"names":[],"mappings":"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"}

package/dest/tx/simulated_tx.js

@@ -1,11 +1,33 @@
+import { optional } from '@aztec/foundation/schemas';
 import { z } from 'zod';
+import { ContractArtifactSchema } from '../abi/abi.js';
+import { ContractInstanceWithAddressSchema } from '../contract/interfaces/contract_instance.js';
 import { Gas } from '../gas/gas.js';
-import { PrivateKernelProverProfileResultSchema } from '../kernel/private_kernel_prover_profile_result.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
-import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
-import { PrivateExecutionResult, collectEnqueuedPublicFunctionCalls, collectPublicTeardownFunctionCall, collectSortedContractClassLogs } from './private_execution_result.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
+import { PrivateExecutionResult, collectSortedContractClassLogs } from './private_execution_result.js';
+import { SimulationStatsSchema } from './profiling.js';
 import { NestedProcessReturnValues, PublicSimulationOutput } from './public_simulation_output.js';
 import { Tx } from './tx.js';
+/*
+ * Optional values that can be overridden during simulation. In order to simulate a transaction with these
+ * set, it *must* be run without the kernel circuits, or validations will fail
+ */ export class SimulationOverrides {
+    contracts;
+    constructor(contracts){
+        this.contracts = contracts;
+    }
+    static get schema() {
+        return z.object({
+            contracts: optional(z.record(z.string(), z.object({
+                instance: ContractInstanceWithAddressSchema,
+                artifact: ContractArtifactSchema
+            })))
+        }).transform(({ contracts })=>{
+            return new SimulationOverrides(contracts);
+        });
+    }
+}
 export class PrivateSimulationResult {
     privateExecutionResult;
     publicInputs;
@@ -16,19 +38,26 @@ export class PrivateSimulationResult {
     getPrivateReturnValues() {
         return accumulatePrivateReturnValues(this.privateExecutionResult);
     }
-    toSimulatedTx() {
+    async toSimulatedTx() {
         const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
-        const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(this.privateExecutionResult);
-        const teardownPublicFunction = collectPublicTeardownFunctionCall(this.privateExecutionResult);
-        const tx = new Tx(this.publicInputs, ClientIvcProof.empty(), contractClassLogs, enqueuedPublicFunctions, teardownPublicFunction);
-        return tx;
+        return await Tx.create({
+            data: this.publicInputs,
+            chonkProof: ChonkProof.empty(),
+            contractClassLogFields: contractClassLogs,
+            publicFunctionCalldata: this.privateExecutionResult.publicFunctionCalldata
+        });
     }
 }
-export class TxSimulationResult extends PrivateSimulationResult {
+export class TxSimulationResult {
+    privateExecutionResult;
+    publicInputs;
     publicOutput;
-    profileResult;
-    constructor(privateExecutionResult, publicInputs, publicOutput, profileResult){
-        super(privateExecutionResult, publicInputs), this.publicOutput = publicOutput, this.profileResult = profileResult;
+    stats;
+    constructor(privateExecutionResult, publicInputs, publicOutput, stats){
+        this.privateExecutionResult = privateExecutionResult;
+        this.publicInputs = publicInputs;
+        this.publicOutput = publicOutput;
+        this.stats = stats;
     }
     get gasUsed() {
         return this.publicOutput?.gasUsed ?? {
@@ -43,50 +72,26 @@ export class TxSimulationResult extends PrivateSimulationResult {
             privateExecutionResult: PrivateExecutionResult.schema,
             publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
             publicOutput: PublicSimulationOutput.schema.optional(),
-            profileResult: PrivateKernelProverProfileResultSchema.optional()
+            stats: optional(SimulationStatsSchema)
         }).transform(TxSimulationResult.from);
     }
     static from(fields) {
-        return new TxSimulationResult(fields.privateExecutionResult, fields.publicInputs, fields.publicOutput, fields.profileResult);
-    }
-    getPublicReturnValues() {
-        return this.publicOutput ? this.publicOutput.publicReturnValues : [];
+        return new TxSimulationResult(fields.privateExecutionResult, fields.publicInputs, fields.publicOutput, fields.stats);
     }
-    static fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput, profileResult) {
-        return new TxSimulationResult(privateSimulationResult.privateExecutionResult, privateSimulationResult.publicInputs, publicOutput, profileResult);
+    static fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput, stats) {
+        return new TxSimulationResult(privateSimulationResult.privateExecutionResult, privateSimulationResult.publicInputs, publicOutput, stats);
     }
     static async random() {
         return new TxSimulationResult(await PrivateExecutionResult.random(), PrivateKernelTailCircuitPublicInputs.empty(), await PublicSimulationOutput.random());
     }
-}
-export class TxProvingResult {
-    privateExecutionResult;
-    publicInputs;
-    clientIvcProof;
-    constructor(privateExecutionResult, publicInputs, clientIvcProof){
-        this.privateExecutionResult = privateExecutionResult;
-        this.publicInputs = publicInputs;
-        this.clientIvcProof = clientIvcProof;
-    }
-    toTx() {
-        const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
-        const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(this.privateExecutionResult);
-        const teardownPublicFunction = collectPublicTeardownFunctionCall(this.privateExecutionResult);
-        const tx = new Tx(this.publicInputs, this.clientIvcProof, contractClassLogs, enqueuedPublicFunctions, teardownPublicFunction);
-        return tx;
-    }
-    static get schema() {
-        return z.object({
-            privateExecutionResult: PrivateExecutionResult.schema,
-            publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
-            clientIvcProof: ClientIvcProof.schema
-        }).transform(TxProvingResult.from);
+    getPrivateReturnValues() {
+        return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).getPrivateReturnValues();
     }
-    static from(fields) {
-        return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.clientIvcProof);
+    toSimulatedTx() {
+        return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).toSimulatedTx();
     }
-    static async random() {
-        return new TxProvingResult(await PrivateExecutionResult.random(), PrivateKernelTailCircuitPublicInputs.empty(), ClientIvcProof.empty());
+    getPublicReturnValues() {
+        return this.publicOutput ? this.publicOutput.publicReturnValues : [];
     }
 }
 /**
@@ -97,7 +102,7 @@ export class TxProvingResult {
  */ export function accumulatePrivateReturnValues(executionResult) {
     const collectPrivateReturnValuesRecursive = (executionResult)=>{
         const acc = new NestedProcessReturnValues(executionResult.returnValues);
-        acc.nested = executionResult.nestedExecutions.map((nestedExecution)=>collectPrivateReturnValuesRecursive(nestedExecution));
+        acc.nested = executionResult.nestedExecutionResults.map((nestedExecutionResult)=>collectPrivateReturnValuesRecursive(nestedExecutionResult));
         return acc;
     };
     return collectPrivateReturnValuesRecursive(executionResult.entrypoint);

package/dest/tx/state_reference.d.ts

@@ -1,8 +1,6 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 import { inspect } from 'util';
 import { z } from 'zod';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
@@ -106,9 +104,13 @@ export declare class StateReference {
             };
         }>;
     }, "strip", z.ZodTypeAny, {
-        partial: PartialStateReference;
         l1ToL2MessageTree: AppendOnlyTreeSnapshot;
+        partial: PartialStateReference;
     }, {
+        l1ToL2MessageTree: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
         partial: {
             noteHashTree: {
                 root: string;
@@ -123,11 +125,11 @@ export declare class StateReference {
                 nextAvailableLeafIndex: string | number | bigint;
             };
         };
+    }>, StateReference, {
         l1ToL2MessageTree: {
             root: string;
             nextAvailableLeafIndex: string | number | bigint;
         };
-    }>, StateReference, {
         partial: {
             noteHashTree: {
                 root: string;
@@ -142,17 +144,17 @@ export declare class StateReference {
                 nextAvailableLeafIndex: string | number | bigint;
             };
         };
-        l1ToL2MessageTree: {
-            root: string;
-            nextAvailableLeafIndex: string | number | bigint;
-        };
     }>;
     getSize(): number;
-    toBuffer(): Buffer;
+    static getFields(fields: FieldsOf<StateReference>): readonly [AppendOnlyTreeSnapshot, PartialStateReference];
+    static from(fields: FieldsOf<StateReference>): StateReference;
+    toBuffer(): Buffer<ArrayBufferLike>;
     toFields(): Fr[];
     static fromBuffer(buffer: Buffer | BufferReader): StateReference;
     static fromFields(fields: Fr[] | FieldReader): StateReference;
     static empty(): StateReference;
+    static random(): StateReference;
+    toAbi(): [ReturnType<AppendOnlyTreeSnapshot['toAbi']>, ReturnType<PartialStateReference['toAbi']>];
     isEmpty(): boolean;
     toInspect(): {
         l1ToL2MessageTree: `0x${string}`;
@@ -160,7 +162,11 @@ export declare class StateReference {
         nullifierTree: `0x${string}`;
         publicDataTree: `0x${string}`;
     };
+    /**
+     * Validates the trees in world state have the expected number of leaves (multiple of number of insertions per tx)
+     */
+    validate(): void;
     [inspect.custom](): string;
     equals(other: this): boolean;
 }
-//# sourceMappingURL=state_reference.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGVfcmVmZXJlbmNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHgvc3RhdGVfcmVmZXJlbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3pELE9BQU8sRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUFxQixNQUFNLDZCQUE2QixDQUFDO0FBQzNGLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRXhELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDL0IsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4QixPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUMvRSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUVyRTs7R0FFRztBQUNILHFCQUFhLGNBQWM7SUFFdkIsNkNBQTZDO0lBQ3RDLGlCQUFpQixFQUFFLHNCQUFzQjtJQUNoRCwwQ0FBMEM7SUFDbkMsT0FBTyxFQUFFLHFCQUFxQjtJQUp2QztJQUNFLDZDQUE2QztJQUN0QyxpQkFBaUIsRUFBRSxzQkFBc0I7SUFDaEQsMENBQTBDO0lBQ25DLE9BQU8sRUFBRSxxQkFBcUIsRUFDbkM7SUFFSixNQUFNLEtBQUssTUFBTTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O09BT2hCO0lBRUQsT0FBTyxXQUVOO0lBRUQsTUFBTSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLGNBQWMsQ0FBQyw0REFFaEQ7SUFFRCxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsY0FBYyxDQUFDLGtCQUUzQztJQUVELFFBQVEsNEJBR1A7SUFFRCxRQUFRLElBQUksRUFBRSxFQUFFLENBUWY7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxHQUFHLGNBQWMsQ0FHL0Q7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsR0FBRyxXQUFXLEdBQUcsY0FBYyxDQU81RDtJQUVELE1BQU0sQ0FBQyxLQUFLLElBQUksY0FBYyxDQUU3QjtJQUVELE1BQU0sQ0FBQyxNQUFNLElBQUksY0FBYyxDQUU5QjtJQUVELEtBQUssSUFBSSxDQUFDLFVBQVUsQ0FBQyxzQkFBc0IsQ0FBQyxPQUFPLENBQUMsQ0FBQyxFQUFFLFVBQVUsQ0FBQyxxQkFBcUIsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBRWpHO0lBRUQsT0FBTyxJQUFJLE9BQU8sQ0FFakI7SUFFRCxTQUFTOzs7OztNQU9SO0lBRUQ7O09BRUc7SUFDSSxRQUFRLFNBZ0JkO0lBRUQsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLFdBT2Y7SUFFTSxNQUFNLENBQUMsS0FBSyxFQUFFLElBQUksR0FBRyxPQUFPLENBRWxDO0NBQ0YifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"state_reference.d.ts","sourceRoot":"","sources":["../../src/tx/state_reference.ts"],"names":[],"mappings":";;;AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE;;GAEG;AACH,qBAAa,cAAc;IAEvB,6CAA6C;IACtC,iBAAiB,EAAE,sBAAsB;IAChD,0CAA0C;IACnC,OAAO,EAAE,qBAAqB;;IAHrC,6CAA6C;IACtC,iBAAiB,EAAE,sBAAsB;IAChD,0CAA0C;IACnC,OAAO,EAAE,qBAAqB;IAGvC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAOhB;IAED,OAAO;IAIP,QAAQ;IAKR,QAAQ,IAAI,EAAE,EAAE;IAUhB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,cAAc;IAKhE,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,cAAc;IAS7D,MAAM,CAAC,KAAK,IAAI,cAAc;IAI9B,OAAO,IAAI,OAAO;IAIlB,SAAS;;;;;;IAST,CAAC,OAAO,CAAC,MAAM,CAAC;IAST,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO;CAGpC"}
+{"version":3,"file":"state_reference.d.ts","sourceRoot":"","sources":["../../src/tx/state_reference.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAC3F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE;;GAEG;AACH,qBAAa,cAAc;IAEvB,6CAA6C;IACtC,iBAAiB,EAAE,sBAAsB;IAChD,0CAA0C;IACnC,OAAO,EAAE,qBAAqB;IAJvC;IACE,6CAA6C;IACtC,iBAAiB,EAAE,sBAAsB;IAChD,0CAA0C;IACnC,OAAO,EAAE,qBAAqB,EACnC;IAEJ,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAOhB;IAED,OAAO,WAEN;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,4DAEhD;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,kBAE3C;IAED,QAAQ,4BAGP;IAED,QAAQ,IAAI,EAAE,EAAE,CAQf;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,cAAc,CAG/D;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,cAAc,CAO5D;IAED,MAAM,CAAC,KAAK,IAAI,cAAc,CAE7B;IAED,MAAM,CAAC,MAAM,IAAI,cAAc,CAE9B;IAED,KAAK,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC,EAAE,UAAU,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC,CAEjG;IAED,OAAO,IAAI,OAAO,CAEjB;IAED,SAAS;;;;;MAOR;IAED;;OAEG;IACI,QAAQ,SAgBd;IAED,CAAC,OAAO,CAAC,MAAM,CAAC,WAOf;IAEM,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAElC;CACF"}

package/dest/tx/state_reference.js

@@ -1,9 +1,11 @@
-import { STATE_REFERENCE_LENGTH } from '@aztec/constants';
+var _computedKey;
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, STATE_REFERENCE_LENGTH } from '@aztec/constants';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { inspect } from 'util';
 import { z } from 'zod';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { PartialStateReference } from './partial_state_reference.js';
+_computedKey = inspect.custom;
 /**
  * Stores snapshots of all the trees but archive.
  */ export class StateReference {
@@ -22,8 +24,17 @@ import { PartialStateReference } from './partial_state_reference.js';
     getSize() {
         return this.l1ToL2MessageTree.getSize() + this.partial.getSize();
     }
+    static getFields(fields) {
+        return [
+            fields.l1ToL2MessageTree,
+            fields.partial
+        ];
+    }
+    static from(fields) {
+        return new StateReference(...StateReference.getFields(fields));
+    }
     toBuffer() {
-        // Note: The order here must match the order in the HeaderLib solidity library.
+        // Note: The order here must match the order in the ProposedHeaderLib solidity library.
         return serializeToBuffer(this.l1ToL2MessageTree, this.partial);
     }
     toFields() {
@@ -47,10 +58,21 @@ import { PartialStateReference } from './partial_state_reference.js';
         return new StateReference(l1ToL2MessageTree, partial);
     }
     static empty() {
-        return new StateReference(AppendOnlyTreeSnapshot.zero(), PartialStateReference.empty());
+        return new StateReference(AppendOnlyTreeSnapshot.empty(), PartialStateReference.empty());
+    }
+    static random() {
+        return new StateReference(AppendOnlyTreeSnapshot.random(), PartialStateReference.random());
+    }
+    toAbi() {
+        return [
+            this.l1ToL2MessageTree.toAbi(),
+            [
+                ...this.partial.toAbi()
+            ]
+        ];
     }
     isEmpty() {
-        return this.l1ToL2MessageTree.isZero() && this.partial.isEmpty();
+        return this.l1ToL2MessageTree.isEmpty() && this.partial.isEmpty();
     }
     toInspect() {
         return {
@@ -60,7 +82,20 @@ import { PartialStateReference } from './partial_state_reference.js';
             publicDataTree: this.partial.publicDataTree.root.toString()
         };
     }
-    [inspect.custom]() {
+    /**
+   * Validates the trees in world state have the expected number of leaves (multiple of number of insertions per tx)
+   */ validate() {
+        if (this.l1ToL2MessageTree.nextAvailableLeafIndex % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP !== 0) {
+            throw new Error(`Invalid L1 to L2 message tree next available leaf index ${this.l1ToL2MessageTree.nextAvailableLeafIndex} (must be a multiple of ${NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP})`);
+        }
+        if (this.partial.noteHashTree.nextAvailableLeafIndex % MAX_NOTE_HASHES_PER_TX !== 0) {
+            throw new Error(`Invalid note hash tree next available leaf index ${this.partial.noteHashTree.nextAvailableLeafIndex} (must be a multiple of ${MAX_NOTE_HASHES_PER_TX})`);
+        }
+        if (this.partial.nullifierTree.nextAvailableLeafIndex % MAX_NULLIFIERS_PER_TX !== 0) {
+            throw new Error(`Invalid nullifier tree next available leaf index ${this.partial.nullifierTree.nextAvailableLeafIndex} (must be a multiple of ${MAX_NULLIFIERS_PER_TX})`);
+        }
+    }
+    [_computedKey]() {
         return `StateReference {
   l1ToL2MessageTree: ${inspect(this.l1ToL2MessageTree)},
   noteHashTree: ${inspect(this.partial.noteHashTree)},
@@ -69,6 +104,6 @@ import { PartialStateReference } from './partial_state_reference.js';
 }`;
     }
     equals(other) {
-        return this.l1ToL2MessageTree.root.equals(other.l1ToL2MessageTree.root) && this.partial.equals(other.partial);
+        return this.l1ToL2MessageTree.equals(other.l1ToL2MessageTree) && this.partial.equals(other.partial);
     }
 }

package/dest/tx/tree_snapshots.d.ts

@@ -1,7 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -10,10 +7,10 @@ import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
  * Stores snapshots of all the trees but archive.
  */
 export declare class TreeSnapshots {
-    readonly l1ToL2MessageTree: AppendOnlyTreeSnapshot;
-    readonly noteHashTree: AppendOnlyTreeSnapshot;
-    readonly nullifierTree: AppendOnlyTreeSnapshot;
-    readonly publicDataTree: AppendOnlyTreeSnapshot;
+    l1ToL2MessageTree: AppendOnlyTreeSnapshot;
+    noteHashTree: AppendOnlyTreeSnapshot;
+    nullifierTree: AppendOnlyTreeSnapshot;
+    publicDataTree: AppendOnlyTreeSnapshot;
     constructor(l1ToL2MessageTree: AppendOnlyTreeSnapshot, noteHashTree: AppendOnlyTreeSnapshot, nullifierTree: AppendOnlyTreeSnapshot, publicDataTree: AppendOnlyTreeSnapshot);
     static get schema(): z.ZodEffects<z.ZodObject<{
         l1ToL2MessageTree: z.ZodEffects<z.ZodObject<{
@@ -110,11 +107,19 @@ export declare class TreeSnapshots {
     }>;
     getSize(): number;
     static fromBuffer(buffer: Buffer | BufferReader): TreeSnapshots;
-    toBuffer(): Buffer;
+    toBuffer(): Buffer<ArrayBufferLike>;
     static fromFields(fields: Fr[] | FieldReader): TreeSnapshots;
     toFields(): Fr[];
     static empty(): TreeSnapshots;
+    /**
+     * Creates a TreeSnapshots instance from a plain object without Zod validation.
+     * This method is optimized for performance and skips validation, making it suitable
+     * for deserializing trusted data (e.g., from C++ via MessagePack).
+     * @param obj - Plain object containing TreeSnapshots fields
+     * @returns A TreeSnapshots instance
+     */
+    static fromPlainObject(obj: any): TreeSnapshots;
     isEmpty(): boolean;
     [inspect.custom](): string;
 }
-//# sourceMappingURL=tree_snapshots.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZV9zbmFwc2hvdHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eC90cmVlX3NuYXBzaG90cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBcUIsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRixPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQy9CLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFFL0U7O0dBRUc7QUFDSCxxQkFBYSxhQUFhO0lBRWYsaUJBQWlCLEVBQUUsc0JBQXNCO0lBQ3pDLFlBQVksRUFBRSxzQkFBc0I7SUFDcEMsYUFBYSxFQUFFLHNCQUFzQjtJQUNyQyxjQUFjLEVBQUUsc0JBQXNCO0lBSi9DLFlBQ1MsaUJBQWlCLEVBQUUsc0JBQXNCLEVBQ3pDLFlBQVksRUFBRSxzQkFBc0IsRUFDcEMsYUFBYSxFQUFFLHNCQUFzQixFQUNyQyxjQUFjLEVBQUUsc0JBQXNCLEVBQzNDO0lBRUosTUFBTSxLQUFLLE1BQU07Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O09BWWhCO0lBRUQsT0FBTyxXQU9OO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksR0FBRyxhQUFhLENBUTlEO0lBRUQsUUFBUSw0QkFHUDtJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLEVBQUUsRUFBRSxHQUFHLFdBQVcsaUJBUzNDO0lBRUQsUUFBUSxJQUFJLEVBQUUsRUFBRSxDQWFmO0lBRUQsTUFBTSxDQUFDLEtBQUssSUFBSSxhQUFhLENBTzVCO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsTUFBTSxDQUFDLGVBQWUsQ0FBQyxHQUFHLEVBQUUsR0FBRyxHQUFHLGFBQWEsQ0FPOUM7SUFFRCxPQUFPLElBQUksT0FBTyxDQU9qQjtJQUVELENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxXQU9mO0NBQ0YifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"tree_snapshots.d.ts","sourceRoot":"","sources":["../../src/tx/tree_snapshots.ts"],"names":[],"mappings":";;;AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAE/E;;GAEG;AACH,qBAAa,aAAa;aAEN,iBAAiB,EAAE,sBAAsB;aACzC,YAAY,EAAE,sBAAsB;aACpC,aAAa,EAAE,sBAAsB;aACrC,cAAc,EAAE,sBAAsB;gBAHtC,iBAAiB,EAAE,sBAAsB,EACzC,YAAY,EAAE,sBAAsB,EACpC,aAAa,EAAE,sBAAsB,EACrC,cAAc,EAAE,sBAAsB;IAGxD,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAYhB;IAED,OAAO;IASP,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa;IAU/D,QAAQ;IAKR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAW5C,QAAQ,IAAI,EAAE,EAAE;IAehB,MAAM,CAAC,KAAK,IAAI,aAAa;IAS7B,OAAO,IAAI,OAAO;IASlB,CAAC,OAAO,CAAC,MAAM,CAAC;CAQjB"}
+{"version":3,"file":"tree_snapshots.d.ts","sourceRoot":"","sources":["../../src/tx/tree_snapshots.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAE/E;;GAEG;AACH,qBAAa,aAAa;IAEf,iBAAiB,EAAE,sBAAsB;IACzC,YAAY,EAAE,sBAAsB;IACpC,aAAa,EAAE,sBAAsB;IACrC,cAAc,EAAE,sBAAsB;IAJ/C,YACS,iBAAiB,EAAE,sBAAsB,EACzC,YAAY,EAAE,sBAAsB,EACpC,aAAa,EAAE,sBAAsB,EACrC,cAAc,EAAE,sBAAsB,EAC3C;IAEJ,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAYhB;IAED,OAAO,WAON;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa,CAQ9D;IAED,QAAQ,4BAGP;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,iBAS3C;IAED,QAAQ,IAAI,EAAE,EAAE,CAaf;IAED,MAAM,CAAC,KAAK,IAAI,aAAa,CAO5B;IAED;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,aAAa,CAO9C;IAED,OAAO,IAAI,OAAO,CAOjB;IAED,CAAC,OAAO,CAAC,MAAM,CAAC,WAOf;CACF"}

package/dest/tx/tree_snapshots.js

@@ -1,8 +1,10 @@
+var _computedKey;
 import { TREE_SNAPSHOTS_LENGTH } from '@aztec/constants';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { inspect } from 'util';
 import { z } from 'zod';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+_computedKey = inspect.custom;
 /**
  * Stores snapshots of all the trees but archive.
  */ export class TreeSnapshots {
@@ -32,7 +34,7 @@ import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
         return new TreeSnapshots(reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(AppendOnlyTreeSnapshot));
     }
     toBuffer() {
-        // Note: The order here must match the order in the HeaderLib solidity library.
+        // Note: The order here must match the order in the ProposedHeaderLib solidity library.
         return serializeToBuffer(this.l1ToL2MessageTree, this.noteHashTree, this.nullifierTree, this.publicDataTree);
     }
     static fromFields(fields) {
@@ -56,12 +58,21 @@ import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
         return fields;
     }
     static empty() {
-        return new TreeSnapshots(AppendOnlyTreeSnapshot.zero(), AppendOnlyTreeSnapshot.zero(), AppendOnlyTreeSnapshot.zero(), AppendOnlyTreeSnapshot.zero());
+        return new TreeSnapshots(AppendOnlyTreeSnapshot.empty(), AppendOnlyTreeSnapshot.empty(), AppendOnlyTreeSnapshot.empty(), AppendOnlyTreeSnapshot.empty());
+    }
+    /**
+   * Creates a TreeSnapshots instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing TreeSnapshots fields
+   * @returns A TreeSnapshots instance
+   */ static fromPlainObject(obj) {
+        return new TreeSnapshots(AppendOnlyTreeSnapshot.fromPlainObject(obj.l1ToL2MessageTree), AppendOnlyTreeSnapshot.fromPlainObject(obj.noteHashTree), AppendOnlyTreeSnapshot.fromPlainObject(obj.nullifierTree), AppendOnlyTreeSnapshot.fromPlainObject(obj.publicDataTree));
     }
     isEmpty() {
-        return this.l1ToL2MessageTree.isZero() && this.noteHashTree.isZero() && this.nullifierTree.isZero() && this.publicDataTree.isZero();
+        return this.l1ToL2MessageTree.isEmpty() && this.noteHashTree.isEmpty() && this.nullifierTree.isEmpty() && this.publicDataTree.isEmpty();
     }
-    [inspect.custom]() {
+    [_computedKey]() {
         return `TreeSnapshots {
   l1ToL2MessageTree: ${inspect(this.l1ToL2MessageTree)},
   noteHashTree: ${inspect(this.noteHashTree)},