@aztec/txe 0.0.1-commit.3469e52 → 0.0.1-commit.350e0a4d

package/dest/utils/block_creation.js

@@ -2,7 +2,7 @@ import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT
 import { CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { Body, L2BlockNew } from '@aztec/stdlib/block';
+import { Body, L2Block } from '@aztec/stdlib/block';
 import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
 import { BlockHeader } from '@aztec/stdlib/tx';
 /**
@@ -12,10 +12,10 @@ import { BlockHeader } from '@aztec/stdlib/tx';
  */ export function getSingleTxBlockRequestHash(blockNumber) {
     return new Fr(blockNumber + 9999); // Why does this need to be a high number? Why do small numbered nullifiers already exist?
 }
-export async function insertTxEffectIntoWorldTrees(txEffect, worldTrees) {
+export async function insertTxEffectIntoWorldTrees(txEffect, worldTrees, l1ToL2Messages = []) {
     await worldTrees.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
     await worldTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map((nullifier)=>nullifier.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
-    await worldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, padArrayEnd(txEffect.l2ToL1Msgs, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+    await worldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
 // We do not need to add public data writes because we apply them as we go.
 }
 export async function makeTXEBlockHeader(worldTrees, globalVariables) {
@@ -31,7 +31,7 @@ export async function makeTXEBlockHeader(worldTrees, globalVariables) {
     });
 }
 /**
- * Creates an L2BlockNew with proper archive chaining.
+ * Creates an L2Block with proper archive chaining.
  * This function:
  * 1. Gets the current archive state as lastArchive for the header
  * 2. Creates the block header
@@ -41,7 +41,7 @@ export async function makeTXEBlockHeader(worldTrees, globalVariables) {
  * @param worldTrees - The world trees to read/write from
  * @param globalVariables - Global variables for the block
  * @param txEffects - Transaction effects to include in the block
- * @returns The created L2BlockNew with proper archive chaining
+ * @returns The created L2Block with proper archive chaining
  */ export async function makeTXEBlock(worldTrees, globalVariables, txEffects) {
     const header = await makeTXEBlockHeader(worldTrees, globalVariables);
     // Update the archive tree with this block's header hash
@@ -49,8 +49,10 @@ export async function makeTXEBlockHeader(worldTrees, globalVariables) {
     // Get the new archive state after updating
     const newArchiveInfo = await worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
     const newArchive = new AppendOnlyTreeSnapshot(new Fr(newArchiveInfo.root), Number(newArchiveInfo.size));
-    // L2BlockNew requires checkpointNumber and indexWithinCheckpoint
+    // L2Block requires checkpointNumber and indexWithinCheckpoint.
+    // TXE uses 1-block-per-checkpoint for testing simplicity, so we can use block number as checkpoint number.
+    // This uses the deprecated fromBlockNumber method intentionally for the TXE testing environment.
     const checkpointNumber = CheckpointNumber.fromBlockNumber(globalVariables.blockNumber);
     const indexWithinCheckpoint = IndexWithinCheckpoint(0);
-    return new L2BlockNew(newArchive, header, new Body(txEffects), checkpointNumber, indexWithinCheckpoint);
+    return new L2Block(newArchive, header, new Body(txEffects), checkpointNumber, indexWithinCheckpoint);
 }

package/dest/utils/encoding.d.ts

@@ -0,0 +1,192 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type ContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHash } from '@aztec/stdlib/block';
+import { type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { z } from 'zod';
+export type ForeignCallSingle = string;
+export type ForeignCallArray = string[];
+export type ForeignCallArgs = (ForeignCallSingle | ForeignCallArray | ContractArtifact | ContractInstanceWithAddress)[];
+export type ForeignCallResult = {
+    values: (ForeignCallSingle | ForeignCallArray)[];
+};
+export declare function fromSingle(obj: ForeignCallSingle): Fr;
+export declare function addressFromSingle(obj: ForeignCallSingle): AztecAddress;
+export declare function blockHashFromSingle(obj: ForeignCallSingle): BlockHash;
+export declare function fromArray(obj: ForeignCallArray): Fr[];
+/**
+ * Converts an array of Noir unsigned integers to a single tightly-packed buffer.
+ * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
+ * @returns A buffer where each byte is correctly represented as a single byte in the buffer.
+ */
+export declare function fromUintArray(obj: ForeignCallArray, uintBitSize: number): Buffer;
+/**
+ * Converts a Noir BoundedVec of unsigned integers into a Buffer. Note that BoundedVecs are structs, and therefore
+ * translated as two separate ForeignCallArray and ForeignCallSingle values (an array and a single field).
+ *
+ * @param storage The array with the BoundedVec's storage (i.e. BoundedVec::storage())
+ * @param length The length of the BoundedVec (i.e. BoundedVec::len())
+ * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
+ * @returns A buffer containing the unsigned integers tightly packed
+ */
+export declare function fromUintBoundedVec(storage: ForeignCallArray, length: ForeignCallSingle, uintBitSize: number): Buffer;
+export declare function toSingle(value: AztecAddress | EthAddress | Fr | Buffer | boolean | number | bigint): ForeignCallSingle;
+export declare function toArray(objs: Fr[]): ForeignCallArray;
+export declare function toSingleOrArray(value: Fr | Fr[]): string | string[];
+export declare function bufferToU8Array(buffer: Buffer): ForeignCallArray;
+/**
+ * Converts a ForeignCallArray into a tuple which represents a nr BoundedVec.
+ * If the input array is shorter than the maxLen, it pads the result with zeros,
+ * so that nr can correctly coerce this result into a BoundedVec.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - the max length of the BoundedVec.
+ * @returns a tuple representing a BoundedVec.
+ */
+export declare function arrayToBoundedVec(bVecStorage: ForeignCallArray, maxLen: number): [ForeignCallArray, ForeignCallSingle];
+/**
+ * Converts an array of arrays representing Noir BoundedVec of nested arrays into its Noir serialized form.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - The max length of the BoundedVec (max num of the nested arrays in the BoundedVec).
+ * @param nestedArrayLength - The length of the nested arrays (each nested array has to have the same length).
+ * @returns Serialized BoundedVec following Noir intrinsic serialization.
+ */
+export declare function arrayOfArraysToBoundedVecOfArrays(bVecStorage: ForeignCallArray[], maxLen: number, nestedArrayLength: number): [ForeignCallArray, ForeignCallSingle];
+export declare function toForeignCallResult(obj: (ForeignCallSingle | ForeignCallArray)[]): {
+    values: (string | ForeignCallArray)[];
+};
+export declare const ForeignCallSingleSchema: z.ZodString;
+export declare const ForeignCallArraySchema: z.ZodArray<z.ZodString>;
+export declare const ForeignCallArgsSchema: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodObject<{
+    name: z.ZodString;
+    aztecVersion: z.ZodDefault<z.ZodString>;
+    functions: z.ZodArray<z.ZodIntersection<z.ZodObject<{
+        name: z.ZodString;
+        functionType: z.ZodEnum<typeof import("@aztec/stdlib/abi").FunctionType>;
+        isOnlySelf: z.ZodBoolean;
+        isStatic: z.ZodBoolean;
+        isInitializer: z.ZodBoolean;
+        parameters: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodType<import("@aztec/stdlib/abi").AbiType, unknown, z.core.$ZodTypeInternals<import("@aztec/stdlib/abi").AbiType, unknown>>;
+            visibility: z.ZodEnum<{
+                databus: "databus";
+                private: "private";
+                public: "public";
+            }>;
+        }, z.core.$strip>>;
+        returnTypes: z.ZodArray<z.ZodType<import("@aztec/stdlib/abi").AbiType, unknown, z.core.$ZodTypeInternals<import("@aztec/stdlib/abi").AbiType, unknown>>>;
+        errorTypes: z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            error_kind: z.ZodLiteral<"string">;
+            string: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            error_kind: z.ZodLiteral<"fmtstring">;
+            length: z.ZodNumber;
+            item_types: z.ZodArray<z.ZodType<import("@aztec/stdlib/abi").AbiType, unknown, z.core.$ZodTypeInternals<import("@aztec/stdlib/abi").AbiType, unknown>>>;
+        }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+            error_kind: z.ZodLiteral<"custom">;
+        }, z.core.$strip>, z.ZodType<import("@aztec/stdlib/abi").AbiType, unknown, z.core.$ZodTypeInternals<import("@aztec/stdlib/abi").AbiType, unknown>>>]>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        bytecode: import("@aztec/foundation/schemas").ZodFor<Buffer<ArrayBufferLike>>;
+        verificationKey: z.ZodOptional<z.ZodString>;
+        debugSymbols: z.ZodString;
+        debug: z.ZodOptional<z.ZodObject<{
+            debugSymbols: z.ZodObject<{
+                location_tree: z.ZodObject<{
+                    locations: z.ZodArray<z.ZodObject<{
+                        parent: z.ZodNullable<z.ZodNumber>;
+                        value: z.ZodObject<{
+                            span: z.ZodObject<{
+                                start: z.ZodNumber;
+                                end: z.ZodNumber;
+                            }, z.core.$strip>;
+                            file: z.ZodNumber;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+                acir_locations: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                brillig_locations: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            }, z.core.$strip>;
+            files: z.ZodRecord<z.ZodString, z.ZodObject<{
+                source: z.ZodString;
+                path: z.ZodString;
+                function_locations: z.ZodArray<z.ZodObject<{
+                    start: z.ZodNumber;
+                    name: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    nonDispatchPublicFunctions: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        functionType: z.ZodEnum<typeof import("@aztec/stdlib/abi").FunctionType>;
+        isOnlySelf: z.ZodBoolean;
+        isStatic: z.ZodBoolean;
+        isInitializer: z.ZodBoolean;
+        parameters: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodType<import("@aztec/stdlib/abi").AbiType, unknown, z.core.$ZodTypeInternals<import("@aztec/stdlib/abi").AbiType, unknown>>;
+            visibility: z.ZodEnum<{
+                databus: "databus";
+                private: "private";
+                public: "public";
+            }>;
+        }, z.core.$strip>>;
+        returnTypes: z.ZodArray<z.ZodType<import("@aztec/stdlib/abi").AbiType, unknown, z.core.$ZodTypeInternals<import("@aztec/stdlib/abi").AbiType, unknown>>>;
+        errorTypes: z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            error_kind: z.ZodLiteral<"string">;
+            string: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            error_kind: z.ZodLiteral<"fmtstring">;
+            length: z.ZodNumber;
+            item_types: z.ZodArray<z.ZodType<import("@aztec/stdlib/abi").AbiType, unknown, z.core.$ZodTypeInternals<import("@aztec/stdlib/abi").AbiType, unknown>>>;
+        }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+            error_kind: z.ZodLiteral<"custom">;
+        }, z.core.$strip>, z.ZodType<import("@aztec/stdlib/abi").AbiType, unknown, z.core.$ZodTypeInternals<import("@aztec/stdlib/abi").AbiType, unknown>>>]>>>;
+    }, z.core.$strip>>;
+    outputs: z.ZodObject<{
+        structs: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<import("@aztec/stdlib/abi").AbiType, unknown, z.core.$ZodTypeInternals<import("@aztec/stdlib/abi").AbiType, unknown>>>>, z.ZodTransform<Record<string, import("@aztec/stdlib/abi").AbiType[]>, Record<string, import("@aztec/stdlib/abi").AbiType[]>>>;
+        globals: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<import("@aztec/stdlib/abi").AbiValue, unknown, z.core.$ZodTypeInternals<import("@aztec/stdlib/abi").AbiValue, unknown>>>>;
+    }, z.core.$strip>;
+    storageLayout: z.ZodRecord<z.ZodString, z.ZodObject<{
+        slot: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+    }, z.core.$strip>>;
+    fileMap: z.ZodRecord<z.ZodCoercedNumber<unknown>, z.ZodObject<{
+        source: z.ZodString;
+        path: z.ZodString;
+        function_locations: z.ZodArray<z.ZodObject<{
+            start: z.ZodNumber;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodIntersection<z.ZodIntersection<z.ZodObject<{
+    version: z.ZodLiteral<2>;
+    salt: import("@aztec/foundation/schemas").ZodFor<Fr>;
+    deployer: import("@aztec/foundation/schemas").ZodFor<AztecAddress>;
+    originalContractClassId: import("@aztec/foundation/schemas").ZodFor<Fr>;
+    initializationHash: import("@aztec/foundation/schemas").ZodFor<Fr>;
+    immutablesHash: import("@aztec/foundation/schemas").ZodFor<Fr>;
+    publicKeys: z.ZodPipe<z.ZodObject<{
+        npkMHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+        ivpkM: z.ZodType<import("@aztec/foundation/schemas").Point, string, z.core.$ZodTypeInternals<import("@aztec/foundation/schemas").Point, string>>;
+        ovpkMHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+        tpkMHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+        mspkMHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+        fbpkMHash: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+    }, z.core.$strip>, z.ZodTransform<import("@aztec/stdlib/keys").PublicKeys, {
+        npkMHash: Fr;
+        ivpkM: import("@aztec/foundation/schemas").Point;
+        ovpkMHash: Fr;
+        tpkMHash: Fr;
+        mspkMHash: Fr;
+        fbpkMHash: Fr;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    currentContractClassId: import("@aztec/foundation/schemas").ZodFor<Fr>;
+}, z.core.$strip>>, z.ZodObject<{
+    address: import("@aztec/foundation/schemas").ZodFor<AztecAddress>;
+}, z.core.$strip>>]>>;
+export declare const ForeignCallResultSchema: z.ZodObject<{
+    values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/utils/encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../src/utils/encoding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,EAAE,KAAK,gBAAgB,EAA0B,MAAM,mBAAmB,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,KAAK,2BAA2B,EAAqC,MAAM,wBAAwB,CAAC;AAE7G,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC;AAEvC,MAAM,MAAM,gBAAgB,GAAG,MAAM,EAAE,CAAC;AAExC,MAAM,MAAM,eAAe,GAAG,CAAC,iBAAiB,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,2BAA2B,CAAC,EAAE,CAAC;AAExH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,CAAC,iBAAiB,GAAG,gBAAgB,CAAC,EAAE,CAAC;CAClD,CAAC;AAEF,wBAAgB,UAAU,CAAC,GAAG,EAAE,iBAAiB,MAEhD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,iBAAiB,gBAEvD;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,iBAAiB,aAEzD;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,gBAAgB,QAE9C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAMhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAOpH;AAID,wBAAgB,QAAQ,CACtB,KAAK,EAAE,YAAY,GAAG,UAAU,GAAG,EAAE,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GACzE,iBAAiB,CAYnB;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,gBAAgB,CAEpD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,EAAE,qBAE/C;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAEhE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,gBAAgB,EAC7B,MAAM,EAAE,MAAM,GACb,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAYvC;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAC/C,WAAW,EAAE,gBAAgB,EAAE,EAC/B,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,MAAM,GACxB,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAsBvC;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,CAAC,iBAAiB,GAAG,gBAAgB,CAAC,EAAE;;EAEhF;AAED,eAAO,MAAM,uBAAuB,aAAa,CAAC;AAElD,eAAO,MAAM,sBAAsB,yBAAsB,CAAC;AAE1D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAEjC,CAAC;AAEF,eAAO,MAAM,uBAAuB;;iBAElC,CAAC"}

package/dest/{util → utils}/encoding.js

@@ -2,6 +2,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { hexToBuffer } from '@aztec/foundation/string';
 import { ContractArtifactSchema } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHash } from '@aztec/stdlib/block';
 import { ContractInstanceWithAddressSchema } from '@aztec/stdlib/contract';
 import { z } from 'zod';
 export function fromSingle(obj) {
@@ -10,6 +11,9 @@ export function fromSingle(obj) {
 export function addressFromSingle(obj) {
     return new AztecAddress(fromSingle(obj));
 }
+export function blockHashFromSingle(obj) {
+    return new BlockHash(fromSingle(obj));
+}
 export function fromArray(obj) {
     return obj.map((str)=>Fr.fromBuffer(hexToBuffer(str)));
 }
@@ -102,8 +106,9 @@ export function bufferToU8Array(buffer) {
     }
     const flattenedStorage = bVecStorage.flat();
     const numFieldsToPad = maxLen * nestedArrayLength - flattenedStorage.length;
-    const flattenedStorageWithPadding = flattenedStorage.concat(Array(numFieldsToPad).fill(new Fr(0)));
-    // At last we get the actual length of the BoundedVec and return the values.
+    // Pad with hex-encoded zeros so the result is uniformly `ForeignCallSingle` (string); raw Fr
+    // instances would JSON-serialize as `{ asBigInt: "0" }` and nargo would reject the response.
+    const flattenedStorageWithPadding = flattenedStorage.concat(toArray(Array(numFieldsToPad).fill(new Fr(0))));
     const len = toSingle(new Fr(bVecStorage.length));
     return [
         flattenedStorageWithPadding,

package/dest/{util → utils}/expected_failure_error.d.ts

@@ -1,4 +1,4 @@
 export declare class ExpectedFailureError extends Error {
     constructor(message: string);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwZWN0ZWRfZmFpbHVyZV9lcnJvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWwvZXhwZWN0ZWRfZmFpbHVyZV9lcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxxQkFBYSxvQkFBcUIsU0FBUSxLQUFLO0lBQzdDLFlBQVksT0FBTyxFQUFFLE1BQU0sRUFFMUI7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwZWN0ZWRfZmFpbHVyZV9lcnJvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2V4cGVjdGVkX2ZhaWx1cmVfZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEscUJBQWEsb0JBQXFCLFNBQVEsS0FBSztJQUM3QyxZQUFZLE9BQU8sRUFBRSxNQUFNLEVBRTFCO0NBQ0YifQ==

package/dest/utils/expected_failure_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expected_failure_error.d.ts","sourceRoot":"","sources":["../../src/utils/expected_failure_error.ts"],"names":[],"mappings":"AAAA,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF"}

package/dest/utils/tx_effect_creation.d.ts

@@ -2,4 +2,4 @@ import { BlockNumber } from '@aztec/foundation/branded-types';
 import type { ExecutionNoteCache } from '@aztec/pxe/simulator';
 import { TxEffect } from '@aztec/stdlib/tx';
 export declare function makeTxEffect(noteCache: ExecutionNoteCache, txBlockNumber: BlockNumber): Promise<TxEffect>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfZWZmZWN0X2NyZWF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvdHhfZWZmZWN0X2NyZWF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5RCxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRS9ELE9BQU8sRUFBRSxRQUFRLEVBQVUsTUFBTSxrQkFBa0IsQ0FBQztBQUVwRCx3QkFBc0IsWUFBWSxDQUFDLFNBQVMsRUFBRSxrQkFBa0IsRUFBRSxhQUFhLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0F1Qi9HIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfZWZmZWN0X2NyZWF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvdHhfZWZmZWN0X2NyZWF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5RCxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRS9ELE9BQU8sRUFBRSxRQUFRLEVBQVUsTUFBTSxrQkFBa0IsQ0FBQztBQUVwRCx3QkFBc0IsWUFBWSxDQUFDLFNBQVMsRUFBRSxrQkFBa0IsRUFBRSxhQUFhLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FxQi9HIn0=

package/dest/utils/tx_effect_creation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tx_effect_creation.d.ts","sourceRoot":"","sources":["../../src/utils/tx_effect_creation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAE9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,EAAE,QAAQ,EAAU,MAAM,kBAAkB,CAAC;AAEpD,wBAAsB,YAAY,CAAC,SAAS,EAAE,kBAAkB,EAAE,aAAa,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAuB/G"}
+{"version":3,"file":"tx_effect_creation.d.ts","sourceRoot":"","sources":["../../src/utils/tx_effect_creation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAE9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,EAAE,QAAQ,EAAU,MAAM,kBAAkB,CAAC;AAEpD,wBAAsB,YAAY,CAAC,SAAS,EAAE,kBAAkB,EAAE,aAAa,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAqB/G"}

package/dest/utils/tx_effect_creation.js

@@ -3,7 +3,6 @@ import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@azte
 import { TxEffect, TxHash } from '@aztec/stdlib/tx';
 export async function makeTxEffect(noteCache, txBlockNumber) {
     const txEffect = TxEffect.empty();
-    noteCache.finish();
     const nonceGenerator = noteCache.getNonceGenerator();
     txEffect.noteHashes = await Promise.all(noteCache.getAllNotes().map(async (pendingNote, i)=>computeUniqueNoteHash(await computeNoteHashNonce(nonceGenerator, i), await siloNoteHash(pendingNote.note.contractAddress, pendingNote.noteHashForConsumption))));
     // Nullifiers are already siloed

package/dest/{util → utils}/txe_account_store.d.ts

@@ -7,4 +7,4 @@ export declare class TXEAccountStore {
     getAccount(key: AztecAddress): Promise<CompleteAddress>;
     setAccount(key: AztecAddress, value: CompleteAddress): Promise<void>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhlX2FjY291bnRfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsL3R4ZV9hY2NvdW50X3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFpQixNQUFNLGlCQUFpQixDQUFDO0FBQ3hFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUV6RCxxQkFBYSxlQUFlOztJQUcxQixZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFFbkM7SUFFSyxVQUFVLENBQUMsR0FBRyxFQUFFLFlBQVksNEJBTWpDO0lBRUssVUFBVSxDQUFDLEdBQUcsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLGVBQWUsaUJBRXpEO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhlX2FjY291bnRfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy90eGVfYWNjb3VudF9zdG9yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBaUIsTUFBTSxpQkFBaUIsQ0FBQztBQUN4RSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFekQscUJBQWEsZUFBZTs7SUFHMUIsWUFBWSxLQUFLLEVBQUUsaUJBQWlCLEVBRW5DO0lBRUssVUFBVSxDQUFDLEdBQUcsRUFBRSxZQUFZLDRCQU1qQztJQUVLLFVBQVUsQ0FBQyxHQUFHLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxlQUFlLGlCQUV6RDtDQUNGIn0=

package/dest/utils/txe_account_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"txe_account_store.d.ts","sourceRoot":"","sources":["../../src/utils/txe_account_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,qBAAa,eAAe;;IAG1B,YAAY,KAAK,EAAE,iBAAiB,EAEnC;IAEK,UAAU,CAAC,GAAG,EAAE,YAAY,4BAMjC;IAEK,UAAU,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,eAAe,iBAEzD;CACF"}

package/dest/utils/txe_artifact_resolver.d.ts

@@ -0,0 +1,37 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { type ContractInstanceWithAddress } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { ContractStore } from '@aztec/pxe/client/lazy';
+import type { ContractArtifactWithHash } from '@aztec/stdlib/contract';
+export interface ResolvedArtifact {
+    artifact: ContractArtifactWithHash;
+    instance: ContractInstanceWithAddress;
+}
+/**
+ * Resolves and caches contract artifacts and their associated instances.
+ *
+ * Artifact hash computation is expensive, so this service deduplicates both completed and in-flight computations.
+ * Two cache levels are kept: full deploys (artifact + computed instance) keyed by the full deploy context, and loaded +
+ * hashed artifacts keyed by the compiled-bytecode hash so deploys of the same contract with different args / salt /
+ * deployer reuse the same `ContractArtifactWithHash`.
+ */
+export declare class TXEArtifactResolver {
+    #private;
+    private readonly contractStore;
+    private readonly schnorrClassId;
+    constructor(contractStore: ContractStore, schnorrClassId: Fr);
+    /** Resolves the Schnorr account contract artifact and instance for the given secret, caching the result. */
+    resolveAccountArtifact(secret: Fr): Promise<ResolvedArtifact>;
+    /** Resolves a contract artifact from disk by path, computes its instance, and caches the result. */
+    resolveDeployArtifact({ rootPath, packageName, contractPath, initializer, args, secret, salt, deployer }: {
+        rootPath: string;
+        packageName: string;
+        contractPath: string;
+        initializer: string;
+        args: Fr[];
+        secret: Fr;
+        salt: Fr;
+        deployer: AztecAddress;
+    }): Promise<ResolvedArtifact>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhlX2FydGlmYWN0X3Jlc29sdmVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvdHhlX2FydGlmYWN0X3Jlc29sdmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUN6RCxPQUFPLEVBQ0wsS0FBSywyQkFBMkIsRUFFakMsTUFBTSwyQkFBMkIsQ0FBQztBQUNuQyxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFHNUMsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDNUQsT0FBTyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQVF2RSxNQUFNLFdBQVcsZ0JBQWdCO0lBQy9CLFFBQVEsRUFBRSx3QkFBd0IsQ0FBQztJQUNuQyxRQUFRLEVBQUUsMkJBQTJCLENBQUM7Q0FDdkM7QUFpQ0Q7Ozs7Ozs7R0FPRztBQUNILHFCQUFhLG1CQUFtQjs7SUFNNUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxhQUFhO0lBQzlCLE9BQU8sQ0FBQyxRQUFRLENBQUMsY0FBYztJQUZqQyxZQUNtQixhQUFhLEVBQUUsYUFBYSxFQUM1QixjQUFjLEVBQUUsRUFBRSxFQUNqQztJQUVKLDRHQUE0RztJQUM1RyxzQkFBc0IsQ0FBQyxNQUFNLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUk1RDtJQUVELG9HQUFvRztJQUM5RixxQkFBcUIsQ0FBQyxFQUMxQixRQUFRLEVBQ1IsV0FBVyxFQUNYLFlBQVksRUFDWixXQUFXLEVBQ1gsSUFBSSxFQUNKLE1BQU0sRUFDTixJQUFJLEVBQ0osUUFBUSxFQUNULEVBQUU7UUFDRCxRQUFRLEVBQUUsTUFBTSxDQUFDO1FBQ2pCLFdBQVcsRUFBRSxNQUFNLENBQUM7UUFDcEIsWUFBWSxFQUFFLE1BQU0sQ0FBQztRQUNyQixXQUFXLEVBQUUsTUFBTSxDQUFDO1FBQ3BCLElBQUksRUFBRSxFQUFFLEVBQUUsQ0FBQztRQUNYLE1BQU0sRUFBRSxFQUFFLENBQUM7UUFDWCxJQUFJLEVBQUUsRUFBRSxDQUFDO1FBQ1QsUUFBUSxFQUFFLFlBQVksQ0FBQztLQUN4QixHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQXdCNUI7Q0E4RkYifQ==

package/dest/utils/txe_artifact_resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"txe_artifact_resolver.d.ts","sourceRoot":"","sources":["../../src/utils/txe_artifact_resolver.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EACL,KAAK,2BAA2B,EAEjC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAG5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAQvE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,wBAAwB,CAAC;IACnC,QAAQ,EAAE,2BAA2B,CAAC;CACvC;AAiCD;;;;;;;GAOG;AACH,qBAAa,mBAAmB;;IAM5B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAFjC,YACmB,aAAa,EAAE,aAAa,EAC5B,cAAc,EAAE,EAAE,EACjC;IAEJ,4GAA4G;IAC5G,sBAAsB,CAAC,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAI5D;IAED,oGAAoG;IAC9F,qBAAqB,CAAC,EAC1B,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,WAAW,EACX,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,QAAQ,EACT,EAAE;QACD,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,EAAE,EAAE,EAAE,CAAC;QACX,MAAM,EAAE,EAAE,CAAC;QACX,IAAI,EAAE,EAAE,CAAC;QACT,QAAQ,EAAE,YAAY,CAAC;KACxB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAwB5B;CA8FF"}

package/dest/utils/txe_artifact_resolver.js

@@ -0,0 +1,161 @@
+import { loadContractArtifact } from '@aztec/aztec.js/abi';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import { PublicKeys, deriveKeys } from '@aztec/aztec.js/keys';
+import { createLogger } from '@aztec/foundation/log';
+import { computeArtifactHash } from '@aztec/stdlib/contract';
+import { createHash } from 'crypto';
+import { createReadStream } from 'fs';
+import { readFile, readdir } from 'fs/promises';
+import { join, parse } from 'path';
+/**
+ * Cache + in-flight map pair. Lookup hits the cache, then awaits an in-flight `compute()` if one
+ * exists, otherwise starts one and stores it. Guarantees `compute()` runs at most once per `key`
+ * across concurrent callers, which matters because `computeArtifactHash` is expensive.
+ */ class AsyncCache {
+    #cache = new Map();
+    #inFlight = new Map();
+    getOrCompute(key, compute) {
+        const cached = this.#cache.get(key);
+        if (cached !== undefined) {
+            return Promise.resolve(cached);
+        }
+        let pending = this.#inFlight.get(key);
+        if (!pending) {
+            pending = (async ()=>{
+                try {
+                    const value = await compute();
+                    this.#cache.set(key, value);
+                    return value;
+                } finally{
+                    this.#inFlight.delete(key);
+                }
+            })();
+            this.#inFlight.set(key, pending);
+        }
+        return pending;
+    }
+}
+/**
+ * Resolves and caches contract artifacts and their associated instances.
+ *
+ * Artifact hash computation is expensive, so this service deduplicates both completed and in-flight computations.
+ * Two cache levels are kept: full deploys (artifact + computed instance) keyed by the full deploy context, and loaded +
+ * hashed artifacts keyed by the compiled-bytecode hash so deploys of the same contract with different args / salt /
+ * deployer reuse the same `ContractArtifactWithHash`.
+ */ export class TXEArtifactResolver {
+    contractStore;
+    schnorrClassId;
+    #deployments;
+    #artifacts;
+    #logger;
+    constructor(contractStore, schnorrClassId){
+        this.contractStore = contractStore;
+        this.schnorrClassId = schnorrClassId;
+        this.#deployments = new AsyncCache();
+        this.#artifacts = new AsyncCache();
+        this.#logger = createLogger('txe:artifact_resolver');
+    }
+    /** Resolves the Schnorr account contract artifact and instance for the given secret, caching the result. */ resolveAccountArtifact(secret) {
+        return this.#deployments.getOrCompute(`SchnorrAccountContract-${secret}`, ()=>this.#computeAccountArtifact(secret));
+    }
+    /** Resolves a contract artifact from disk by path, computes its instance, and caches the result. */ async resolveDeployArtifact({ rootPath, packageName, contractPath, initializer, args, secret, salt, deployer }) {
+        const publicKeys = secret.equals(Fr.ZERO) ? PublicKeys.default() : (await deriveKeys(secret)).publicKeys;
+        const publicKeysHash = await publicKeys.hash();
+        const artifactPath = await this.#resolveArtifactPath(rootPath, packageName, contractPath);
+        const fileHash = await this.#fastHashFile(artifactPath);
+        const { dir: contractDirectory, base: contractFilename } = parse(contractPath);
+        const cacheKey = `${contractDirectory ?? ''}-${contractFilename}-${initializer}-${args.map((arg)=>arg.toString()).join('-')}-${publicKeysHash}-${salt}-${deployer}-${fileHash}`;
+        return this.#deployments.getOrCompute(cacheKey, ()=>this.#computeDeployArtifact(artifactPath, fileHash, initializer, args, salt, publicKeys, publicKeysHash, deployer));
+    }
+    async #resolveArtifactPath(rootPath, packageName, contractPath) {
+        const { dir: contractDirectory, base: contractFilename } = parse(contractPath);
+        if (contractDirectory) {
+            if (contractDirectory.includes('@')) {
+                // env.deploy("../path/to/workspace/root@packageName/contractName")
+                const [workspace, pkg] = contractDirectory.split('@');
+                const targetPath = join(rootPath, workspace, '/target');
+                this.#logger.debug(`Looking for compiled artifact in workspace ${targetPath}`);
+                return join(targetPath, `${pkg}-${contractFilename}.json`);
+            } else {
+                // env.deploy("../path/to/contract/root/contractName")
+                const targetPath = join(rootPath, contractDirectory, '/target');
+                this.#logger.debug(`Looking for compiled artifact in ${targetPath}`);
+                const [artifactPath] = (await readdir(targetPath)).filter((file)=>file.endsWith(`-${contractFilename}.json`));
+                return artifactPath;
+            }
+        } else {
+            // env.deploy("contractName")
+            return join(rootPath, './target', `${packageName}-${contractFilename}.json`);
+        }
+    }
+    async #computeAccountArtifact(secret) {
+        const [artifactFromStore, classWithPreimage] = await Promise.all([
+            this.contractStore.getContractArtifact(this.schnorrClassId),
+            this.contractStore.getContractClassWithPreimage(this.schnorrClassId)
+        ]);
+        if (!artifactFromStore || !classWithPreimage) {
+            throw new Error(`SchnorrAccount not found in shared contract store at class id ${this.schnorrClassId.toString()}`);
+        }
+        const artifact = {
+            ...artifactFromStore,
+            artifactHash: classWithPreimage.artifactHash
+        };
+        const keys = await deriveKeys(secret);
+        const args = [
+            keys.publicKeys.ivpkM.x,
+            keys.publicKeys.ivpkM.y
+        ];
+        const instance = await getContractInstanceFromInstantiationParams(artifact, {
+            constructorArgs: args,
+            skipArgsDecoding: true,
+            salt: Fr.ONE,
+            publicKeys: keys.publicKeys,
+            constructorArtifact: 'constructor',
+            deployer: AztecAddress.ZERO
+        });
+        return {
+            artifact,
+            instance
+        };
+    }
+    async #computeDeployArtifact(artifactPath, fileHash, initializer, args, salt, publicKeys, publicKeysHash, deployer) {
+        // Inner cache: artifact load + hash depends only on the compiled bytecode (`fileHash`), so subsequent deploys of
+        // the same contract — regardless of constructor args / deployer / salt — reuse the same `ContractArtifactWithHash`.
+        const artifact = await this.#artifacts.getOrCompute(fileHash, async ()=>{
+            this.#logger.debug(`Loading compiled artifact ${artifactPath}`);
+            const artifactJSON = JSON.parse(await readFile(artifactPath, 'utf-8'));
+            const artifactWithoutHash = loadContractArtifact(artifactJSON);
+            return {
+                ...artifactWithoutHash,
+                artifactHash: await computeArtifactHash(artifactWithoutHash)
+            };
+        });
+        this.#logger.debug(`Deploy ${artifact.name} with initializer ${initializer}(${args}) and public keys hash ${publicKeysHash}`);
+        const instance = await getContractInstanceFromInstantiationParams(artifact, {
+            constructorArgs: args,
+            skipArgsDecoding: true,
+            salt,
+            publicKeys,
+            constructorArtifact: initializer || undefined,
+            deployer
+        });
+        return {
+            artifact,
+            instance
+        };
+    }
+    #fastHashFile(path) {
+        return new Promise((resolve)=>{
+            const fd = createReadStream(path);
+            const hash = createHash('sha1');
+            hash.setEncoding('hex');
+            fd.on('end', function() {
+                hash.end();
+                resolve(hash.read());
+            });
+            fd.pipe(hash);
+        });
+    }
+}

package/dest/utils/txe_public_contract_data_source.d.ts

@@ -0,0 +1,20 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { ContractStore } from '@aztec/pxe/server';
+import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+export declare class TXEPublicContractDataSource implements ContractDataSource {
+    private blockNumber;
+    private contractStore;
+    constructor(blockNumber: BlockNumber, contractStore: ContractStore);
+    getBlockNumber(): Promise<BlockNumber>;
+    getContractClass(id: Fr): Promise<ContractClassPublic | undefined>;
+    getBytecodeCommitment(id: Fr): Promise<Fr | undefined>;
+    getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
+    getContractClassIds(): Promise<Fr[]>;
+    getContractArtifact(address: AztecAddress): Promise<ContractArtifact | undefined>;
+    getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+    registerContractFunctionSignatures(_signatures: []): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhlX3B1YmxpY19jb250cmFjdF9kYXRhX3NvdXJjZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3R4ZV9wdWJsaWNfY29udHJhY3RfZGF0YV9zb3VyY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzVFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLGtCQUFrQixFQUFFLDJCQUEyQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFbkgscUJBQWEsMkJBQTRCLFlBQVcsa0JBQWtCO0lBRWxFLE9BQU8sQ0FBQyxXQUFXO0lBQ25CLE9BQU8sQ0FBQyxhQUFhO0lBRnZCLFlBQ1UsV0FBVyxFQUFFLFdBQVcsRUFDeEIsYUFBYSxFQUFFLGFBQWEsRUFDbEM7SUFFSixjQUFjLElBQUksT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQUVyQztJQUVLLGdCQUFnQixDQUFDLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLG1CQUFtQixHQUFHLFNBQVMsQ0FBQyxDQVl2RTtJQUVLLHFCQUFxQixDQUFDLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLEVBQUUsR0FBRyxTQUFTLENBQUMsQ0FHM0Q7SUFFSyxXQUFXLENBQUMsT0FBTyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsMkJBQTJCLEdBQUcsU0FBUyxDQUFDLENBSXpGO0lBRUQsbUJBQW1CLElBQUksT0FBTyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBRW5DO0lBRUssbUJBQW1CLENBQUMsT0FBTyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsZ0JBQWdCLEdBQUcsU0FBUyxDQUFDLENBR3RGO0lBRUssb0JBQW9CLENBQUMsT0FBTyxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FHekc7SUFFRCxrQ0FBa0MsQ0FBQyxXQUFXLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFakU7Q0FDRiJ9

package/dest/utils/txe_public_contract_data_source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"txe_public_contract_data_source.d.ts","sourceRoot":"","sources":["../../src/utils/txe_public_contract_data_source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAEnH,qBAAa,2BAA4B,YAAW,kBAAkB;IAElE,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,aAAa;IAFvB,YACU,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,aAAa,EAClC;IAEJ,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC,CAErC;IAEK,gBAAgB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAYvE;IAEK,qBAAqB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAG3D;IAEK,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,GAAG,SAAS,CAAC,CAIzF;IAED,mBAAmB,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC,CAEnC;IAEK,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAGtF;IAEK,oBAAoB,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAGzG;IAED,kCAAkC,CAAC,WAAW,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjE;CACF"}

package/dest/utils/txe_public_contract_data_source.js

@@ -0,0 +1,51 @@
+export class TXEPublicContractDataSource {
+    blockNumber;
+    contractStore;
+    constructor(blockNumber, contractStore){
+        this.blockNumber = blockNumber;
+        this.contractStore = contractStore;
+    }
+    getBlockNumber() {
+        return Promise.resolve(this.blockNumber);
+    }
+    async getContractClass(id) {
+        const contractClass = await this.contractStore.getContractClassWithPreimage(id);
+        if (!contractClass) {
+            return;
+        }
+        return {
+            id: contractClass.id,
+            artifactHash: contractClass.artifactHash,
+            packedBytecode: contractClass.packedBytecode,
+            privateFunctionsRoot: contractClass.privateFunctionsRoot,
+            version: contractClass.version
+        };
+    }
+    async getBytecodeCommitment(id) {
+        const contractClass = await this.contractStore.getContractClassWithPreimage(id);
+        return contractClass?.publicBytecodeCommitment;
+    }
+    async getContract(address) {
+        const instance = await this.contractStore.getContractInstance(address);
+        // TXE has no contract updates, so the current class always equals the original.
+        return instance && {
+            ...instance,
+            address,
+            currentContractClassId: instance.originalContractClassId
+        };
+    }
+    getContractClassIds() {
+        throw new Error('Method not implemented.');
+    }
+    async getContractArtifact(address) {
+        const instance = await this.getContract(address);
+        return instance && this.contractStore.getContractArtifact(instance.originalContractClassId);
+    }
+    async getDebugFunctionName(address, selector) {
+        const instance = await this.getContract(address);
+        return instance && this.contractStore.getDebugFunctionName(instance.originalContractClassId, selector);
+    }
+    registerContractFunctionSignatures(_signatures) {
+        return Promise.resolve();
+    }
+}

package/dest/worker.bundle.js

@@ -0,0 +1,3 @@
+import { createRequire as __txeCreateRequire } from 'node:module';
+const require = __txeCreateRequire(import.meta.url);
+import{TXEDispatcher,activeSessionCount,createLogger}from"./chunk-R3ZWQEFL.js";import{__name}from"./chunk-BJVAAXNA.js";import{BackendType,Barretenberg,BarretenbergSync}from"@aztec/bb.js";import{parentPort,workerData}from"node:worker_threads";Barretenberg.initSingleton({backend:BackendType.Wasm,skipSrsInit:!0,threads:1});BarretenbergSync.initSingleton({backend:BackendType.Wasm});if(!parentPort)throw new Error("worker.ts must be loaded as a worker_thread");var port=parentPort,logger=createLogger("txe:worker"),dispatcherOpts={contractStoreSourceDir:workerData.contractStoreSourceDir,schnorrClassId:workerData.schnorrClassId},dispatcher=new TXEDispatcher(logger,dispatcherOpts);function serializeError(err){return err instanceof Error?{message:err.message,name:err.name,stack:err.stack}:{message:String(err)}}__name(serializeError,"serializeError");process.env.TXE_WORKER_MEMSTAT==="1"&&setInterval(()=>{let m=process.memoryUsage();port.postMessage({type:"memstat",sessions:activeSessionCount(),rss:m.rss,heapTotal:m.heapTotal,heapUsed:m.heapUsed,external:m.external,arrayBuffers:m.arrayBuffers})},2e3).unref();port.on("message",msg=>{switch(msg.type){case"foreign-call":(async()=>{try{let value=await dispatcher.resolve_foreign_call(msg.callData);port.postMessage({type:"result",requestId:msg.requestId,ok:!0,value})}catch(err){port.postMessage({type:"result",requestId:msg.requestId,ok:!1,error:serializeError(err)})}})();return;case"dispose-session":dispatcher.disposeSession(msg.sessionId).catch(err=>logger.warn("disposeSession failed",err));return}});