@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/tx/public_simulation_output.js

@@ -0,0 +1,79 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { schemas } from '@aztec-labs/foundation/schemas';
+import times from 'lodash.times';
+import { z } from 'zod';
+import { SimulationError } from '../errors/simulation_error.js';
+import { Gas } from '../gas/gas.js';
+import { DebugLog } from '../logs/debug_log.js';
+import { NullishToUndefined } from '../schemas/schemas.js';
+import { TxEffect } from '../tx/tx_effect.js';
+import { GlobalVariables } from './global_variables.js';
+/** Return values of simulating complete callstack. */ export class NestedProcessReturnValues {
+    values;
+    nested;
+    constructor(values, nested){
+        this.values = values;
+        this.nested = nested ?? [];
+    }
+    equals(other) {
+        return this.values?.length === other.values?.length && this.nested.length === other.nested.length && (this.values === undefined || this.values.every((v, i)=>v.equals(other.values[i]))) && this.nested.every((n, i)=>n.equals(other.nested[i]));
+    }
+    static get schema() {
+        return z.object({
+            values: NullishToUndefined(z.array(schemas.Fr)),
+            nested: z.array(z.lazy(()=>NestedProcessReturnValues.schema))
+        }).transform(({ values, nested })=>new NestedProcessReturnValues(values, nested));
+    }
+    static fromPlainObject(obj) {
+        return new NestedProcessReturnValues(obj.values?.map(Fr.fromPlainObject), obj.nested?.map(NestedProcessReturnValues.fromPlainObject));
+    }
+    static empty() {
+        return new NestedProcessReturnValues([]);
+    }
+    static random(depth = 1) {
+        return new NestedProcessReturnValues(times(3, Fr.random), depth > 0 ? [
+            NestedProcessReturnValues.random(depth - 1)
+        ] : []);
+    }
+}
+/**
+ * Outputs of processing the public component of a transaction.
+ */ export class PublicSimulationOutput {
+    revertReason;
+    globalVariables;
+    txEffect;
+    publicReturnValues;
+    gasUsed;
+    debugLogs;
+    constructor(revertReason, globalVariables, txEffect, publicReturnValues, gasUsed, debugLogs = []){
+        this.revertReason = revertReason;
+        this.globalVariables = globalVariables;
+        this.txEffect = txEffect;
+        this.publicReturnValues = publicReturnValues;
+        this.gasUsed = gasUsed;
+        this.debugLogs = debugLogs;
+    }
+    static get schema() {
+        return z.object({
+            revertReason: SimulationError.schema.optional(),
+            globalVariables: GlobalVariables.schema,
+            txEffect: TxEffect.schema,
+            publicReturnValues: z.array(NestedProcessReturnValues.schema),
+            gasUsed: z.object({
+                totalGas: Gas.schema,
+                teardownGas: Gas.schema,
+                publicGas: Gas.schema,
+                billedGas: Gas.schema
+            }),
+            debugLogs: z.array(DebugLog.schema).default([])
+        }).transform((fields)=>new PublicSimulationOutput(fields.revertReason, fields.globalVariables, fields.txEffect, fields.publicReturnValues, fields.gasUsed, fields.debugLogs));
+    }
+    static async random() {
+        return new PublicSimulationOutput(await SimulationError.random(), GlobalVariables.empty(), TxEffect.empty(), times(2, NestedProcessReturnValues.random), {
+            teardownGas: Gas.random(),
+            totalGas: Gas.random(),
+            publicGas: Gas.random(),
+            billedGas: Gas.random()
+        });
+    }
+}

package/dest/tx/simulated_tx.d.ts

@@ -0,0 +1,148 @@
+import { type ZodFor } from '@aztec-labs/foundation/schemas';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { z } from 'zod';
+import { type ContractInstanceWithAddress } from '../contract/interfaces/contract_instance.js';
+import type { GasUsed } from '../gas/gas_used.js';
+import { type PublicStorageOverride } from '../interfaces/public_storage_override.js';
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import type { OffchainEffect } from './offchain_effect.js';
+import { PrivateExecutionResult } from './private_execution_result.js';
+import { type SimulationStats } from './profiling.js';
+import { NestedProcessReturnValues, PublicSimulationOutput } from './public_simulation_output.js';
+import { Tx } from './tx.js';
+export type ContractOverrides = Record<string, {
+    instance: ContractInstanceWithAddress;
+}>;
+export declare class SimulationOverrides {
+    publicStorage?: PublicStorageOverride[];
+    contracts?: ContractOverrides;
+    constructor(args?: {
+        publicStorage?: PublicStorageOverride[];
+        contracts?: ContractOverrides;
+    });
+    static get schema(): z.ZodPipe<z.ZodObject<{
+        publicStorage: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            contract: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+            slot: ZodFor<import("@aztec-labs/foundation/schemas").Fr>;
+            value: ZodFor<import("@aztec-labs/foundation/schemas").Fr>;
+        }, z.core.$strip>>>>, z.ZodTransform<{
+            contract: import("../aztec-address/index.js").AztecAddress;
+            slot: import("@aztec-labs/foundation/schemas").Fr;
+            value: import("@aztec-labs/foundation/schemas").Fr;
+        }[] | undefined, {
+            contract: import("../aztec-address/index.js").AztecAddress;
+            slot: import("@aztec-labs/foundation/schemas").Fr;
+            value: import("@aztec-labs/foundation/schemas").Fr;
+        }[] | null | undefined>>;
+        contracts: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+            instance: z.ZodIntersection<z.ZodIntersection<z.ZodObject<{
+                version: z.ZodLiteral<2>;
+                salt: ZodFor<import("@aztec-labs/foundation/schemas").Fr>;
+                deployer: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+                originalContractClassId: ZodFor<import("@aztec-labs/foundation/schemas").Fr>;
+                initializationHash: ZodFor<import("@aztec-labs/foundation/schemas").Fr>;
+                immutablesHash: ZodFor<import("@aztec-labs/foundation/schemas").Fr>;
+                publicKeys: z.ZodPipe<z.ZodObject<{
+                    npkMHash: z.ZodType<import("@aztec-labs/foundation/schemas").Fr, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Fr, string>>;
+                    ivpkM: z.ZodType<import("@aztec-labs/foundation/schemas").Point, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Point, string>>;
+                    ovpkMHash: z.ZodType<import("@aztec-labs/foundation/schemas").Fr, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Fr, string>>;
+                    tpkMHash: z.ZodType<import("@aztec-labs/foundation/schemas").Fr, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Fr, string>>;
+                    mspkMHash: z.ZodType<import("@aztec-labs/foundation/schemas").Fr, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Fr, string>>;
+                    fbpkMHash: z.ZodType<import("@aztec-labs/foundation/schemas").Fr, string, z.core.$ZodTypeInternals<import("@aztec-labs/foundation/schemas").Fr, string>>;
+                }, z.core.$strip>, z.ZodTransform<import("../keys/public_keys.js").PublicKeys, {
+                    npkMHash: import("@aztec-labs/foundation/schemas").Fr;
+                    ivpkM: import("@aztec-labs/foundation/schemas").Point;
+                    ovpkMHash: import("@aztec-labs/foundation/schemas").Fr;
+                    tpkMHash: import("@aztec-labs/foundation/schemas").Fr;
+                    mspkMHash: import("@aztec-labs/foundation/schemas").Fr;
+                    fbpkMHash: import("@aztec-labs/foundation/schemas").Fr;
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                currentContractClassId: ZodFor<import("@aztec-labs/foundation/schemas").Fr>;
+            }, z.core.$strip>>, z.ZodObject<{
+                address: ZodFor<import("../aztec-address/index.js").AztecAddress>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>>, z.ZodTransform<Record<string, {
+            instance: {
+                version: 2;
+                salt: import("@aztec-labs/foundation/schemas").Fr;
+                deployer: import("../aztec-address/index.js").AztecAddress;
+                originalContractClassId: import("@aztec-labs/foundation/schemas").Fr;
+                initializationHash: import("@aztec-labs/foundation/schemas").Fr;
+                immutablesHash: import("@aztec-labs/foundation/schemas").Fr;
+                publicKeys: import("../keys/public_keys.js").PublicKeys;
+            } & {
+                currentContractClassId: import("@aztec-labs/foundation/schemas").Fr;
+            } & {
+                address: import("../aztec-address/index.js").AztecAddress;
+            };
+        }> | undefined, Record<string, {
+            instance: {
+                version: 2;
+                salt: import("@aztec-labs/foundation/schemas").Fr;
+                deployer: import("../aztec-address/index.js").AztecAddress;
+                originalContractClassId: import("@aztec-labs/foundation/schemas").Fr;
+                initializationHash: import("@aztec-labs/foundation/schemas").Fr;
+                immutablesHash: import("@aztec-labs/foundation/schemas").Fr;
+                publicKeys: import("../keys/public_keys.js").PublicKeys;
+            } & {
+                currentContractClassId: import("@aztec-labs/foundation/schemas").Fr;
+            } & {
+                address: import("../aztec-address/index.js").AztecAddress;
+            };
+        }> | null | undefined>>;
+    }, z.core.$strip>, z.ZodTransform<SimulationOverrides, {
+        publicStorage: {
+            contract: import("../aztec-address/index.js").AztecAddress;
+            slot: import("@aztec-labs/foundation/schemas").Fr;
+            value: import("@aztec-labs/foundation/schemas").Fr;
+        }[] | undefined;
+        contracts: Record<string, {
+            instance: {
+                version: 2;
+                salt: import("@aztec-labs/foundation/schemas").Fr;
+                deployer: import("../aztec-address/index.js").AztecAddress;
+                originalContractClassId: import("@aztec-labs/foundation/schemas").Fr;
+                initializationHash: import("@aztec-labs/foundation/schemas").Fr;
+                immutablesHash: import("@aztec-labs/foundation/schemas").Fr;
+                publicKeys: import("../keys/public_keys.js").PublicKeys;
+            } & {
+                currentContractClassId: import("@aztec-labs/foundation/schemas").Fr;
+            } & {
+                address: import("../aztec-address/index.js").AztecAddress;
+            };
+        }> | undefined;
+    }>>;
+}
+export declare class PrivateSimulationResult {
+    privateExecutionResult: PrivateExecutionResult;
+    publicInputs: PrivateKernelTailCircuitPublicInputs;
+    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs);
+    getPrivateReturnValues(): NestedProcessReturnValues;
+    toSimulatedTx(): Promise<Tx>;
+}
+export declare class TxSimulationResult {
+    privateExecutionResult: PrivateExecutionResult;
+    publicInputs: PrivateKernelTailCircuitPublicInputs;
+    publicOutput?: PublicSimulationOutput | undefined;
+    stats?: SimulationStats | undefined;
+    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs, publicOutput?: PublicSimulationOutput | undefined, stats?: SimulationStats | undefined);
+    /** Returns offchain effects collected from private execution. */
+    get offchainEffects(): OffchainEffect[];
+    get gasUsed(): GasUsed;
+    static get schema(): ZodFor<TxSimulationResult>;
+    static from(fields: Omit<FieldsOf<TxSimulationResult>, 'gasUsed' | 'offchainEffects'>): TxSimulationResult;
+    static fromPrivateSimulationResultAndPublicOutput(privateSimulationResult: PrivateSimulationResult, publicOutput?: PublicSimulationOutput, stats?: SimulationStats): TxSimulationResult;
+    static random(): Promise<TxSimulationResult>;
+    getPrivateReturnValues(): NestedProcessReturnValues;
+    toSimulatedTx(): Promise<Tx>;
+    getPublicReturnValues(): NestedProcessReturnValues[];
+}
+/**
+ * Recursively accumulate the return values of a call result and its nested executions,
+ * so they can be retrieved in order.
+ * @param executionResult
+ * @returns
+ */
+export declare function accumulatePrivateReturnValues(executionResult: PrivateExecutionResult): NestedProcessReturnValues;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"simulated_tx.d.ts","sourceRoot":"","sources":["../../src/tx/simulated_tx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,gCAAgC,CAAC;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,KAAK,2BAA2B,EAEjC,MAAM,6CAA6C,CAAC;AAErD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,KAAK,qBAAqB,EAA+B,MAAM,0CAA0C,CAAC;AACnH,OAAO,EAAE,oCAAoC,EAAE,MAAM,wDAAwD,CAAC;AAE9G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAEL,sBAAsB,EAGvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,KAAK,eAAe,EAAyB,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAClG,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAS7B,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAA+B;IAAE,QAAQ,EAAE,2BAA2B,CAAA;CAAE,CAAC,CAAC;AAQvH,qBAAa,mBAAmB;IACvB,aAAa,CAAC,EAAE,qBAAqB,EAAE,CAAC;IACxC,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAErC,YAAY,IAAI,GAAE;QAAE,aAAa,CAAC,EAAE,qBAAqB,EAAE,CAAC;QAAC,SAAS,CAAC,EAAE,iBAAiB,CAAA;KAAO,EAGhG;IAED,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiBhB;CACF;AAED,qBAAa,uBAAuB;IAEzB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;IAF3D,YACS,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EACvD;IAEJ,sBAAsB,8BAErB;IAEK,aAAa,IAAI,OAAO,CAAC,EAAE,CAAC,CASjC;CACF;AAED,qBAAa,kBAAkB;IAEpB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;IAClD,YAAY,CAAC;IACb,KAAK,CAAC;IAJf,YACS,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAClD,YAAY,CAAC,oCAAwB,EACrC,KAAK,CAAC,6BAAiB,EAC5B;IAEJ,iEAAiE;IACjE,IAAI,eAAe,IAAI,cAAc,EAAE,CAEtC;IAED,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,GAAG,iBAAiB,CAAC,sBAOpF;IAED,MAAM,CAAC,0CAA0C,CAC/C,uBAAuB,EAAE,uBAAuB,EAChD,YAAY,CAAC,EAAE,sBAAsB,EACrC,KAAK,CAAC,EAAE,eAAe,sBAQxB;IAED,OAAa,MAAM,gCAMlB;IAED,sBAAsB,8BAErB;IAED,aAAa,IAAI,OAAO,CAAC,EAAE,CAAC,CAE3B;IAED,qBAAqB,gCAEpB;CACF;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,eAAe,EAAE,sBAAsB,GAAG,yBAAyB,CAWhH"}

package/dest/tx/simulated_tx.js

@@ -0,0 +1,119 @@
+import { optional } from '@aztec-labs/foundation/schemas';
+import { z } from 'zod';
+import { ContractInstanceWithAddressSchema } from '../contract/interfaces/contract_instance.js';
+import { Gas } from '../gas/gas.js';
+import { MAX_RPC_CONTRACT_OVERRIDES_LEN, MAX_RPC_PUBLIC_STORAGE_OVERRIDES_LEN } from '../interfaces/api_limit.js';
+import { PublicStorageOverrideSchema } from '../interfaces/public_storage_override.js';
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
+import { PrivateExecutionResult, collectOffchainEffects, 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. `publicStorage` writes to the public-data
+ * tree fork. `contracts` overrides contract instances in the contract DB.
+ * In order to simulate a transaction with these set, it *must* be run without the kernel circuits,
+ * or validations will fail.
+ */ export class SimulationOverrides {
+    publicStorage;
+    contracts;
+    constructor(args = {}){
+        this.publicStorage = args.publicStorage?.length ? args.publicStorage : undefined;
+        this.contracts = args.contracts && Object.keys(args.contracts).length > 0 ? args.contracts : undefined;
+    }
+    static get schema() {
+        return z.object({
+            publicStorage: optional(z.array(PublicStorageOverrideSchema).max(MAX_RPC_PUBLIC_STORAGE_OVERRIDES_LEN, {
+                message: `publicStorage must have at most ${MAX_RPC_PUBLIC_STORAGE_OVERRIDES_LEN} entries`
+            })),
+            contracts: optional(z.record(z.string(), z.object({
+                instance: ContractInstanceWithAddressSchema
+            })).refine((contracts)=>Object.keys(contracts).length <= MAX_RPC_CONTRACT_OVERRIDES_LEN, {
+                message: `contracts must have at most ${MAX_RPC_CONTRACT_OVERRIDES_LEN} entries`
+            }))
+        }).transform((args)=>new SimulationOverrides(args));
+    }
+}
+export class PrivateSimulationResult {
+    privateExecutionResult;
+    publicInputs;
+    constructor(privateExecutionResult, publicInputs){
+        this.privateExecutionResult = privateExecutionResult;
+        this.publicInputs = publicInputs;
+    }
+    getPrivateReturnValues() {
+        return accumulatePrivateReturnValues(this.privateExecutionResult);
+    }
+    async toSimulatedTx() {
+        const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
+        return await Tx.create({
+            data: this.publicInputs,
+            chonkProof: ChonkProof.empty(),
+            contractClassLogFields: contractClassLogs,
+            publicFunctionCalldata: this.privateExecutionResult.publicFunctionCalldata
+        });
+    }
+}
+export class TxSimulationResult {
+    privateExecutionResult;
+    publicInputs;
+    publicOutput;
+    stats;
+    constructor(privateExecutionResult, publicInputs, publicOutput, stats){
+        this.privateExecutionResult = privateExecutionResult;
+        this.publicInputs = publicInputs;
+        this.publicOutput = publicOutput;
+        this.stats = stats;
+    }
+    /** Returns offchain effects collected from private execution. */ get offchainEffects() {
+        return collectOffchainEffects(this.privateExecutionResult);
+    }
+    get gasUsed() {
+        return this.publicOutput?.gasUsed ?? {
+            totalGas: this.publicInputs.gasUsed,
+            billedGas: this.publicInputs.gasUsed,
+            teardownGas: Gas.empty(),
+            publicGas: Gas.empty()
+        };
+    }
+    static get schema() {
+        return z.object({
+            privateExecutionResult: PrivateExecutionResult.schema,
+            publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
+            publicOutput: PublicSimulationOutput.schema.optional(),
+            stats: optional(SimulationStatsSchema)
+        }).transform(TxSimulationResult.from);
+    }
+    static from(fields) {
+        return new TxSimulationResult(fields.privateExecutionResult, fields.publicInputs, fields.publicOutput, fields.stats);
+    }
+    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());
+    }
+    getPrivateReturnValues() {
+        return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).getPrivateReturnValues();
+    }
+    toSimulatedTx() {
+        return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).toSimulatedTx();
+    }
+    getPublicReturnValues() {
+        return this.publicOutput ? this.publicOutput.publicReturnValues : [];
+    }
+}
+/**
+ * Recursively accumulate the return values of a call result and its nested executions,
+ * so they can be retrieved in order.
+ * @param executionResult
+ * @returns
+ */ export function accumulatePrivateReturnValues(executionResult) {
+    const collectPrivateReturnValuesRecursive = (executionResult)=>{
+        const acc = new NestedProcessReturnValues(executionResult.returnValues);
+        acc.nested = executionResult.nestedExecutionResults.map((nestedExecutionResult)=>collectPrivateReturnValuesRecursive(nestedExecutionResult));
+        return acc;
+    };
+    return collectPrivateReturnValuesRecursive(executionResult.entrypoint);
+}

package/dest/tx/state_reference.d.ts

@@ -0,0 +1,88 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, BufferSink, FieldReader } from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { PartialStateReference } from './partial_state_reference.js';
+/**
+ * Stores snapshots of all the trees but archive.
+ */
+export declare class StateReference {
+    /** Snapshot of the l1 to l2 message tree. */
+    l1ToL2MessageTree: AppendOnlyTreeSnapshot;
+    /** Reference to the rest of the state. */
+    partial: PartialStateReference;
+    constructor(
+    /** Snapshot of the l1 to l2 message tree. */
+    l1ToL2MessageTree: AppendOnlyTreeSnapshot, 
+    /** Reference to the rest of the state. */
+    partial: PartialStateReference);
+    static get schema(): z.ZodPipe<z.ZodObject<{
+        l1ToL2MessageTree: z.ZodPipe<z.ZodObject<{
+            root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+            nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
+            root: Fr;
+            nextAvailableLeafIndex: number;
+        }>>;
+        partial: z.ZodPipe<z.ZodObject<{
+            noteHashTree: z.ZodPipe<z.ZodObject<{
+                root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+                nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+            }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
+                root: Fr;
+                nextAvailableLeafIndex: number;
+            }>>;
+            nullifierTree: z.ZodPipe<z.ZodObject<{
+                root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+                nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+            }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
+                root: Fr;
+                nextAvailableLeafIndex: number;
+            }>>;
+            publicDataTree: z.ZodPipe<z.ZodObject<{
+                root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+                nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+            }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
+                root: Fr;
+                nextAvailableLeafIndex: number;
+            }>>;
+        }, z.core.$strip>, z.ZodTransform<PartialStateReference, {
+            noteHashTree: AppendOnlyTreeSnapshot;
+            nullifierTree: AppendOnlyTreeSnapshot;
+            publicDataTree: AppendOnlyTreeSnapshot;
+        }>>;
+    }, z.core.$strip>, z.ZodTransform<StateReference, {
+        l1ToL2MessageTree: AppendOnlyTreeSnapshot;
+        partial: PartialStateReference;
+    }>>;
+    getSize(): number;
+    static getFields(fields: FieldsOf<StateReference>): readonly [AppendOnlyTreeSnapshot, PartialStateReference];
+    static from(fields: FieldsOf<StateReference>): StateReference;
+    toBuffer(): Buffer;
+    toBuffer(sink: BufferSink): void;
+    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}`;
+        noteHashTree: `0x${string}`;
+        nullifierTree: `0x${string}`;
+        publicDataTree: `0x${string}`;
+    };
+    /**
+     * Validates the partial-state trees have the expected number of leaves (multiple of number of insertions per tx).
+     *
+     * The L1-to-L2 message tree is not checked: it grows by real message counts at compact (unaligned)
+     * indices, so its next-available leaf index is no longer a multiple of any per-block subtree size.
+     */
+    validate(): void;
+    [inspect.custom](): string;
+    equals(other: this): boolean;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGVfcmVmZXJlbmNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHgvc3RhdGVfcmVmZXJlbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBbUIsTUFBTSxrQ0FBa0MsQ0FBQztBQUMxRyxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUM3RCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQy9CLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDL0UsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFckU7O0dBRUc7QUFDSCxxQkFBYSxjQUFjO0lBRXZCLDZDQUE2QztJQUN0QyxpQkFBaUIsRUFBRSxzQkFBc0I7SUFDaEQsMENBQTBDO0lBQ25DLE9BQU8sRUFBRSxxQkFBcUI7SUFKdkM7SUFDRSw2Q0FBNkM7SUFDdEMsaUJBQWlCLEVBQUUsc0JBQXNCO0lBQ2hELDBDQUEwQztJQUNuQyxPQUFPLEVBQUUscUJBQXFCLEVBQ25DO0lBRUosTUFBTSxLQUFLLE1BQU07Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O1FBT2hCO0lBRUQsT0FBTyxXQUVOO0lBRUQsTUFBTSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLGNBQWMsQ0FBQyw0REFFaEQ7SUFFRCxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsY0FBYyxDQUFDLGtCQUUzQztJQUdELFFBQVEsSUFBSSxNQUFNLENBQUM7SUFDbkIsUUFBUSxDQUFDLElBQUksRUFBRSxVQUFVLEdBQUcsSUFBSSxDQUFDO0lBUWpDLFFBQVEsSUFBSSxFQUFFLEVBQUUsQ0FRZjtJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxZQUFZLEdBQUcsY0FBYyxDQUcvRDtJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLEVBQUUsRUFBRSxHQUFHLFdBQVcsR0FBRyxjQUFjLENBTzVEO0lBRUQsTUFBTSxDQUFDLEtBQUssSUFBSSxjQUFjLENBRTdCO0lBRUQsTUFBTSxDQUFDLE1BQU0sSUFBSSxjQUFjLENBRTlCO0lBRUQsS0FBSyxJQUFJLENBQUMsVUFBVSxDQUFDLHNCQUFzQixDQUFDLE9BQU8sQ0FBQyxDQUFDLEVBQUUsVUFBVSxDQUFDLHFCQUFxQixDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FFakc7SUFFRCxPQUFPLElBQUksT0FBTyxDQUVqQjtJQUVELFNBQVM7Ozs7O01BT1I7SUFFRDs7Ozs7T0FLRztJQUNJLFFBQVEsU0FXZDtJQUVELENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxXQU9mO0lBRU0sTUFBTSxDQUFDLEtBQUssRUFBRSxJQUFJLEdBQUcsT0FBTyxDQUVsQztDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"state_reference.d.ts","sourceRoot":"","sources":["../../src/tx/state_reference.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAmB,MAAM,kCAAkC,CAAC;AAC1G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAOhB;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;IAGD,QAAQ,IAAI,MAAM,CAAC;IACnB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IAQjC,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;;;;;OAKG;IACI,QAAQ,SAWd;IAED,CAAC,OAAO,CAAC,MAAM,CAAC,WAOf;IAEM,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAElC;CACF"}

package/dest/tx/state_reference.js

@@ -0,0 +1,111 @@
+var _computedKey;
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, STATE_REFERENCE_LENGTH } from '@aztec-labs/constants';
+import { BufferReader, BufferSink, FieldReader, serializeToSink } from '@aztec-labs/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 {
+    l1ToL2MessageTree;
+    partial;
+    constructor(/** Snapshot of the l1 to l2 message tree. */ l1ToL2MessageTree, /** Reference to the rest of the state. */ partial){
+        this.l1ToL2MessageTree = l1ToL2MessageTree;
+        this.partial = partial;
+    }
+    static get schema() {
+        return z.object({
+            l1ToL2MessageTree: AppendOnlyTreeSnapshot.schema,
+            partial: PartialStateReference.schema
+        }).transform(({ l1ToL2MessageTree, partial })=>new StateReference(l1ToL2MessageTree, partial));
+    }
+    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(sink) {
+        if (!sink) {
+            return BufferSink.serialize(this);
+        }
+        serializeToSink(sink, this.l1ToL2MessageTree, this.partial);
+    }
+    toFields() {
+        const fields = [
+            ...this.l1ToL2MessageTree.toFields(),
+            ...this.partial.toFields()
+        ];
+        if (fields.length !== STATE_REFERENCE_LENGTH) {
+            throw new Error(`Invalid number of fields for StateReference. Expected ${STATE_REFERENCE_LENGTH}, got ${fields.length}`);
+        }
+        return fields;
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new StateReference(reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(PartialStateReference));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        const l1ToL2MessageTree = AppendOnlyTreeSnapshot.fromFields(reader);
+        const partial = PartialStateReference.fromFields(reader);
+        return new StateReference(l1ToL2MessageTree, partial);
+    }
+    static 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.isEmpty() && this.partial.isEmpty();
+    }
+    toInspect() {
+        return {
+            l1ToL2MessageTree: this.l1ToL2MessageTree.root.toString(),
+            noteHashTree: this.partial.noteHashTree.root.toString(),
+            nullifierTree: this.partial.nullifierTree.root.toString(),
+            publicDataTree: this.partial.publicDataTree.root.toString()
+        };
+    }
+    /**
+   * Validates the partial-state trees have the expected number of leaves (multiple of number of insertions per tx).
+   *
+   * The L1-to-L2 message tree is not checked: it grows by real message counts at compact (unaligned)
+   * indices, so its next-available leaf index is no longer a multiple of any per-block subtree size.
+   */ validate() {
+        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)},
+  nullifierTree: ${inspect(this.partial.nullifierTree)},
+  publicDataTree: ${inspect(this.partial.publicDataTree)},
+}`;
+    }
+    equals(other) {
+        return this.l1ToL2MessageTree.equals(other.l1ToL2MessageTree) && this.partial.equals(other.partial);
+    }
+}

package/dest/tx/tree_snapshots.d.ts

@@ -0,0 +1,68 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, BufferSink, FieldReader } from '@aztec-labs/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+/**
+ * Stores snapshots of all the trees but archive.
+ */
+export declare class TreeSnapshots {
+    l1ToL2MessageTree: AppendOnlyTreeSnapshot;
+    noteHashTree: AppendOnlyTreeSnapshot;
+    nullifierTree: AppendOnlyTreeSnapshot;
+    publicDataTree: AppendOnlyTreeSnapshot;
+    constructor(l1ToL2MessageTree: AppendOnlyTreeSnapshot, noteHashTree: AppendOnlyTreeSnapshot, nullifierTree: AppendOnlyTreeSnapshot, publicDataTree: AppendOnlyTreeSnapshot);
+    static get schema(): z.ZodPipe<z.ZodObject<{
+        l1ToL2MessageTree: z.ZodPipe<z.ZodObject<{
+            root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+            nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
+            root: Fr;
+            nextAvailableLeafIndex: number;
+        }>>;
+        noteHashTree: z.ZodPipe<z.ZodObject<{
+            root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+            nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
+            root: Fr;
+            nextAvailableLeafIndex: number;
+        }>>;
+        nullifierTree: z.ZodPipe<z.ZodObject<{
+            root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+            nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
+            root: Fr;
+            nextAvailableLeafIndex: number;
+        }>>;
+        publicDataTree: z.ZodPipe<z.ZodObject<{
+            root: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+            nextAvailableLeafIndex: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<AppendOnlyTreeSnapshot, {
+            root: Fr;
+            nextAvailableLeafIndex: number;
+        }>>;
+    }, z.core.$strip>, z.ZodTransform<TreeSnapshots, {
+        l1ToL2MessageTree: AppendOnlyTreeSnapshot;
+        noteHashTree: AppendOnlyTreeSnapshot;
+        nullifierTree: AppendOnlyTreeSnapshot;
+        publicDataTree: AppendOnlyTreeSnapshot;
+    }>>;
+    getSize(): number;
+    static fromBuffer(buffer: Buffer | BufferReader): TreeSnapshots;
+    toBuffer(): Buffer;
+    toBuffer(sink: BufferSink): void;
+    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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZV9zbmFwc2hvdHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eC90cmVlX3NuYXBzaG90cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUM5RCxPQUFPLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxXQUFXLEVBQW1CLE1BQU0sa0NBQWtDLENBQUM7QUFDMUcsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUMvQixPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBRS9FOztHQUVHO0FBQ0gscUJBQWEsYUFBYTtJQUVmLGlCQUFpQixFQUFFLHNCQUFzQjtJQUN6QyxZQUFZLEVBQUUsc0JBQXNCO0lBQ3BDLGFBQWEsRUFBRSxzQkFBc0I7SUFDckMsY0FBYyxFQUFFLHNCQUFzQjtJQUovQyxZQUNTLGlCQUFpQixFQUFFLHNCQUFzQixFQUN6QyxZQUFZLEVBQUUsc0JBQXNCLEVBQ3BDLGFBQWEsRUFBRSxzQkFBc0IsRUFDckMsY0FBYyxFQUFFLHNCQUFzQixFQUMzQztJQUVKLE1BQU0sS0FBSyxNQUFNOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O1FBWWhCO0lBRUQsT0FBTyxXQU9OO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksR0FBRyxhQUFhLENBUTlEO0lBR0QsUUFBUSxJQUFJLE1BQU0sQ0FBQztJQUNuQixRQUFRLENBQUMsSUFBSSxFQUFFLFVBQVUsR0FBRyxJQUFJLENBQUM7SUFRakMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsV0FBVyxpQkFTM0M7SUFFRCxRQUFRLElBQUksRUFBRSxFQUFFLENBYWY7SUFFRCxNQUFNLENBQUMsS0FBSyxJQUFJLGFBQWEsQ0FPNUI7SUFFRDs7Ozs7O09BTUc7SUFDSCxNQUFNLENBQUMsZUFBZSxDQUFDLEdBQUcsRUFBRSxHQUFHLEdBQUcsYUFBYSxDQU85QztJQUVELE9BQU8sSUFBSSxPQUFPLENBT2pCO0lBRUQsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLFdBT2Y7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_snapshots.d.ts","sourceRoot":"","sources":["../../src/tx/tree_snapshots.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAmB,MAAM,kCAAkC,CAAC;AAC1G,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAYhB;IAED,OAAO,WAON;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa,CAQ9D;IAGD,QAAQ,IAAI,MAAM,CAAC;IACnB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IAQjC,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"}