@aztec/txe 0.0.0-test.1 → 0.0.1-commit.0b941701

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

@@ -1 +1 @@
-{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../src/util/encoding.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,KAAK,gBAAgB,EAA0B,MAAM,mBAAmB,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,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,SAAS,CAAC,GAAG,EAAE,gBAAgB,QAE9C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAMhF;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,EAAE,GAAG,YAAY,GAAG,iBAAiB,CAElE;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,gBAAgB,CAEpD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAEhE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAYhH;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,CAAC,iBAAiB,GAAG,gBAAgB,CAAC,EAAE;;EAEhF;AAED,eAAO,MAAM,uBAAuB,aAAa,CAAC;AAElD,eAAO,MAAM,sBAAsB,iCAAsB,CAAC;AAE1D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEjC,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;;;EAElC,CAAC"}
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../src/util/encoding.ts"],"names":[],"mappings":"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"}

package/dest/util/encoding.js

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+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';
@@ -16,7 +16,7 @@ export function fromArray(obj) {
 /**
  * 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
+ * @returns A buffer where each byte is correctly represented as a single byte in the buffer.
  */ export function fromUintArray(obj, uintBitSize) {
     if (uintBitSize % 8 !== 0) {
         throw new Error(`u${uintBitSize} is not a supported type in Noir`);
@@ -24,12 +24,43 @@ export function fromArray(obj) {
     const uintByteSize = uintBitSize / 8;
     return Buffer.concat(obj.map((str)=>hexToBuffer(str).slice(-uintByteSize)));
 }
-export function toSingle(obj) {
-    return obj.toString().slice(2);
+/**
+ * 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 function fromUintBoundedVec(storage, length, uintBitSize) {
+    if (uintBitSize % 8 !== 0) {
+        throw new Error(`u${uintBitSize} is not a supported type in Noir`);
+    }
+    const uintByteSize = uintBitSize / 8;
+    const boundedStorage = storage.slice(0, fromSingle(length).toNumber());
+    return Buffer.concat(boundedStorage.map((str)=>hexToBuffer(str).slice(-uintByteSize)));
+}
+// Just like toACVMField in yarn-project/simulator/src/private/acvm/serialize.ts but returns a ForeignCallSingle
+// instead of an ACVMField.
+export function toSingle(value) {
+    let valueAsField;
+    if (Buffer.isBuffer(value)) {
+        valueAsField = Fr.fromBuffer(value);
+    } else if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'bigint') {
+        valueAsField = new Fr(value);
+    } else if (typeof value === 'string') {
+        valueAsField = Fr.fromHexString(value);
+    } else {
+        valueAsField = value;
+    }
+    return valueAsField.toString().slice(2);
 }
 export function toArray(objs) {
     return objs.map((obj)=>obj.toString());
 }
+export function toSingleOrArray(value) {
+    return Array.isArray(value) ? value.map(toSingle) : toSingle(value);
+}
 export function bufferToU8Array(buffer) {
     return toArray(Array.from(buffer).map((byte)=>new Fr(byte)));
 }
@@ -37,24 +68,48 @@ export function bufferToU8Array(buffer) {
  * 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 array
+ * @param bVecStorage - The array underlying the BoundedVec.
  * @param maxLen - the max length of the BoundedVec.
  * @returns a tuple representing a BoundedVec.
- */ export function arrayToBoundedVec(array, maxLen) {
-    if (array.length > maxLen) {
-        throw new Error(`Array of length ${array.length} larger than maxLen ${maxLen}`);
+ */ export function arrayToBoundedVec(bVecStorage, maxLen) {
+    if (bVecStorage.length > maxLen) {
+        throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
     }
-    const lengthDiff = maxLen - array.length;
+    const lengthDiff = maxLen - bVecStorage.length;
     // We pad the array to the maxLen of the BoundedVec.
     const zeroPaddingArray = toArray(Array(lengthDiff).fill(new Fr(0)));
     // These variable names match with the BoundedVec members in nr:
-    const storage = array.concat(zeroPaddingArray);
-    const len = toSingle(new Fr(array.length));
+    const storage = bVecStorage.concat(zeroPaddingArray);
+    const len = toSingle(new Fr(bVecStorage.length));
     return [
         storage,
         len
     ];
 }
+/**
+ * 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 function arrayOfArraysToBoundedVecOfArrays(bVecStorage, maxLen, nestedArrayLength) {
+    if (bVecStorage.length > maxLen) {
+        throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+    }
+    // Check that all nested arrays have length nestedArrayLength
+    if (!bVecStorage.every((nestedArray)=>nestedArray.length === nestedArrayLength)) {
+        throw new Error(`Nested array length passed in from Noir does not correspond to the length obtained in TS: ${nestedArrayLength} !== ${bVecStorage[0].length}`);
+    }
+    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.
+    const len = toSingle(new Fr(bVecStorage.length));
+    return [
+        flattenedStorageWithPadding,
+        len
+    ];
+}
 export function toForeignCallResult(obj) {
     return {
         values: obj

package/dest/util/expected_failure_error.d.ts

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

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

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

package/dest/util/txe_account_store.d.ts

@@ -0,0 +1,10 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { CompleteAddress } from '@aztec/stdlib/contract';
+export declare class TXEAccountStore {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    getAccount(key: AztecAddress): Promise<CompleteAddress>;
+    setAccount(key: AztecAddress, value: CompleteAddress): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhlX2FjY291bnRfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsL3R4ZV9hY2NvdW50X3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFpQixNQUFNLGlCQUFpQixDQUFDO0FBQ3hFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUV6RCxxQkFBYSxlQUFlOztJQUcxQixZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFFbkM7SUFFSyxVQUFVLENBQUMsR0FBRyxFQUFFLFlBQVksNEJBTWpDO0lBRUssVUFBVSxDQUFDLEdBQUcsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLGVBQWUsaUJBRXpEO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"txe_account_store.d.ts","sourceRoot":"","sources":["../../src/util/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/util/{txe_account_data_provider.js → txe_account_store.js}

@@ -1,5 +1,5 @@
 import { CompleteAddress } from '@aztec/stdlib/contract';
-export class TXEAccountDataProvider {
+export class TXEAccountStore {
     #accounts;
     constructor(store){
         this.#accounts = store.openMap('accounts');

package/dest/util/txe_contract_store.d.ts

@@ -0,0 +1,12 @@
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import { Fr } from '@aztec/aztec.js/fields';
+import { ContractStore } from '@aztec/pxe/server';
+export type ContractArtifactWithHash = ContractArtifact & {
+    artifactHash: Fr;
+};
+export declare class TXEContractStore extends ContractStore {
+    #private;
+    addContractArtifact(id: Fr, artifact: ContractArtifact | ContractArtifactWithHash): Promise<void>;
+    getContractArtifact(contractClassId: Fr): Promise<ContractArtifact | ContractArtifactWithHash | undefined>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhlX2NvbnRyYWN0X3N0b3JlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbC90eGVfY29udHJhY3Rfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDNUMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWxELE1BQU0sTUFBTSx3QkFBd0IsR0FBRyxnQkFBZ0IsR0FBRztJQUFFLFlBQVksRUFBRSxFQUFFLENBQUE7Q0FBRSxDQUFDO0FBTy9FLHFCQUFhLGdCQUFpQixTQUFRLGFBQWE7O0lBRzNCLG1CQUFtQixDQUN2QyxFQUFFLEVBQUUsRUFBRSxFQUNOLFFBQVEsRUFBRSxnQkFBZ0IsR0FBRyx3QkFBd0IsR0FDcEQsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUtmO0lBRXFCLG1CQUFtQixDQUN2QyxlQUFlLEVBQUUsRUFBRSxHQUNsQixPQUFPLENBQUMsZ0JBQWdCLEdBQUcsd0JBQXdCLEdBQUcsU0FBUyxDQUFDLENBUWxFO0NBQ0YifQ==

package/dest/util/txe_contract_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"txe_contract_store.d.ts","sourceRoot":"","sources":["../../src/util/txe_contract_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD,MAAM,MAAM,wBAAwB,GAAG,gBAAgB,GAAG;IAAE,YAAY,EAAE,EAAE,CAAA;CAAE,CAAC;AAO/E,qBAAa,gBAAiB,SAAQ,aAAa;;IAG3B,mBAAmB,CACvC,EAAE,EAAE,EAAE,EACN,QAAQ,EAAE,gBAAgB,GAAG,wBAAwB,GACpD,OAAO,CAAC,IAAI,CAAC,CAKf;IAEqB,mBAAmB,CACvC,eAAe,EAAE,EAAE,GAClB,OAAO,CAAC,gBAAgB,GAAG,wBAAwB,GAAG,SAAS,CAAC,CAQlE;CACF"}

package/dest/util/txe_contract_store.js

@@ -0,0 +1,22 @@
+import { Fr } from '@aztec/aztec.js/fields';
+import { ContractStore } from '@aztec/pxe/server';
+/*
+ * A contract store that stores contract artifacts with their hashes. Since
+ * TXE typically deploys the same contract again and again for multiple tests, caching
+ * the *very* expensive artifact hash computation improves testing speed significantly.
+ */ export class TXEContractStore extends ContractStore {
+    #artifactHashes = new Map();
+    async addContractArtifact(id, artifact) {
+        if ('artifactHash' in artifact) {
+            this.#artifactHashes.set(id.toString(), artifact.artifactHash.toBuffer());
+        }
+        await super.addContractArtifact(id, artifact);
+    }
+    async getContractArtifact(contractClassId) {
+        const artifact = await super.getContractArtifact(contractClassId);
+        if (artifact && this.#artifactHashes.has(contractClassId.toString())) {
+            artifact.artifactHash = Fr.fromBuffer(this.#artifactHashes.get(contractClassId.toString()));
+        }
+        return artifact;
+    }
+}

package/dest/util/txe_public_contract_data_source.d.ts

@@ -1,20 +1,21 @@
-import { Fr } from '@aztec/foundation/fields';
+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, type ContractDataSource, type ContractInstanceWithAddress, type PublicFunction } from '@aztec/stdlib/contract';
-import type { TXE } from '../oracle/txe_oracle.js';
+import { type ContractClassPublic, type ContractDataSource, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 export declare class TXEPublicContractDataSource implements ContractDataSource {
-    private txeOracle;
-    constructor(txeOracle: TXE);
-    getPublicFunction(address: AztecAddress, selector: FunctionSelector): Promise<PublicFunction | undefined>;
-    getBlockNumber(): Promise<number>;
+    #private;
+    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>;
-    getContractFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
-    registerContractFunctionSignatures(_address: AztecAddress, _signatures: []): Promise<void>;
-    addContractClass(_contractClass: ContractClassPublic): Promise<void>;
+    getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+    registerContractFunctionSignatures(_signatures: []): Promise<void>;
 }
-//# sourceMappingURL=txe_public_contract_data_source.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhlX3B1YmxpY19jb250cmFjdF9kYXRhX3NvdXJjZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWwvdHhlX3B1YmxpY19jb250cmFjdF9kYXRhX3NvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDOUQsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxLQUFLLGdCQUFnQixFQUFFLGdCQUFnQixFQUFnQixNQUFNLG1CQUFtQixDQUFDO0FBQzFGLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sRUFDTCxLQUFLLG1CQUFtQixFQUN4QixLQUFLLGtCQUFrQixFQUN2QixLQUFLLDJCQUEyQixFQUlqQyxNQUFNLHdCQUF3QixDQUFDO0FBRWhDLHFCQUFhLDJCQUE0QixZQUFXLGtCQUFrQjs7SUFHbEUsT0FBTyxDQUFDLFdBQVc7SUFDbkIsT0FBTyxDQUFDLGFBQWE7SUFGdkIsWUFDVSxXQUFXLEVBQUUsV0FBVyxFQUN4QixhQUFhLEVBQUUsYUFBYSxFQUNsQztJQUVKLGNBQWMsSUFBSSxPQUFPLENBQUMsV0FBVyxDQUFDLENBRXJDO0lBRUssZ0JBQWdCLENBQUMsRUFBRSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsbUJBQW1CLEdBQUcsU0FBUyxDQUFDLENBZ0N2RTtJQUVLLHFCQUFxQixDQUFDLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLEVBQUUsR0FBRyxTQUFTLENBQUMsQ0FHM0Q7SUFFSyxXQUFXLENBQUMsT0FBTyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsMkJBQTJCLEdBQUcsU0FBUyxDQUFDLENBR3pGO0lBRUQsbUJBQW1CLElBQUksT0FBTyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBRW5DO0lBRUssbUJBQW1CLENBQUMsT0FBTyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsZ0JBQWdCLEdBQUcsU0FBUyxDQUFDLENBR3RGO0lBRUssb0JBQW9CLENBQUMsT0FBTyxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FFekc7SUFFRCxrQ0FBa0MsQ0FBQyxXQUFXLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFakU7Q0FDRiJ9

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

@@ -1 +1 @@
-{"version":3,"file":"txe_public_contract_data_source.d.ts","sourceRoot":"","sources":["../../src/util/txe_public_contract_data_source.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,cAAc,EAEpB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,yBAAyB,CAAC;AAEnD,qBAAa,2BAA4B,YAAW,kBAAkB;IACxD,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,GAAG;IAE5B,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAQ/G,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;IAI3B,gBAAgB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC;IA0BlE,qBAAqB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;IAKtD,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,GAAG,SAAS,CAAC;IAK1F,mBAAmB,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;IAI9B,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAKjF,uBAAuB,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAgB7G,kCAAkC,CAAC,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAK1F,gBAAgB,CAAC,cAAc,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAIrE"}
+{"version":3,"file":"txe_public_contract_data_source.d.ts","sourceRoot":"","sources":["../../src/util/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,EAAgB,MAAM,mBAAmB,CAAC;AAC1F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAIjC,MAAM,wBAAwB,CAAC;AAEhC,qBAAa,2BAA4B,YAAW,kBAAkB;;IAGlE,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,CAgCvE;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,CAGzF;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,CAEzG;IAED,kCAAkC,CAAC,WAAW,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjE;CACF"}

package/dest/util/txe_public_contract_data_source.js

@@ -1,56 +1,52 @@
-import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { PrivateFunctionsTree } from '@aztec/pxe/server';
-import { FunctionSelector } from '@aztec/stdlib/abi';
-import { computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { FunctionType } from '@aztec/stdlib/abi';
+import { computePrivateFunctionsRoot, computePublicBytecodeCommitment, getContractClassPrivateFunctionFromArtifact } from '@aztec/stdlib/contract';
 export class TXEPublicContractDataSource {
-    txeOracle;
-    constructor(txeOracle){
-        this.txeOracle = txeOracle;
-    }
-    async getPublicFunction(address, selector) {
-        const bytecode = await this.txeOracle.getContractDataProvider().getBytecode(address, selector);
-        if (!bytecode) {
-            return undefined;
-        }
-        return {
-            bytecode,
-            selector
-        };
+    blockNumber;
+    contractStore;
+    #privateFunctionsRoot;
+    constructor(blockNumber, contractStore){
+        this.blockNumber = blockNumber;
+        this.contractStore = contractStore;
+        this.#privateFunctionsRoot = new Map();
     }
     getBlockNumber() {
-        return this.txeOracle.getBlockNumber();
+        return Promise.resolve(this.blockNumber);
     }
     async getContractClass(id) {
-        const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
-        const artifact = await this.txeOracle.getContractDataProvider().getContractArtifact(id);
-        const tree = await PrivateFunctionsTree.create(artifact);
-        const privateFunctionsRoot = await tree.getFunctionTreeRoot();
-        const publicFunctions = [];
-        if (contractClass.packedBytecode.length > 0) {
-            publicFunctions.push({
-                selector: FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
-                bytecode: contractClass.packedBytecode
-            });
+        const contractClass = await this.contractStore.getContractClass(id);
+        if (!contractClass) {
+            return;
+        }
+        const artifact = await this.contractStore.getContractArtifact(id);
+        if (!artifact) {
+            return;
+        }
+        let privateFunctionsRoot;
+        if (!this.#privateFunctionsRoot.has(id.toString())) {
+            const privateFunctions = await Promise.all(artifact.functions.filter((fn)=>fn.functionType === FunctionType.PRIVATE).map((fn)=>getContractClassPrivateFunctionFromArtifact(fn)));
+            privateFunctionsRoot = await computePrivateFunctionsRoot(privateFunctions);
+            this.#privateFunctionsRoot.set(id.toString(), privateFunctionsRoot.toBuffer());
+        } else {
+            privateFunctionsRoot = Fr.fromBuffer(this.#privateFunctionsRoot.get(id.toString()));
         }
         return {
             id,
             artifactHash: contractClass.artifactHash,
             packedBytecode: contractClass.packedBytecode,
-            publicFunctions: publicFunctions,
-            privateFunctionsRoot: new Fr(privateFunctionsRoot.root),
+            privateFunctionsRoot,
             version: contractClass.version,
             privateFunctions: [],
-            unconstrainedFunctions: []
+            utilityFunctions: []
         };
     }
     async getBytecodeCommitment(id) {
-        const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
-        return computePublicBytecodeCommitment(contractClass.packedBytecode);
+        const contractClass = await this.contractStore.getContractClass(id);
+        return contractClass && computePublicBytecodeCommitment(contractClass.packedBytecode);
     }
     async getContract(address) {
-        const instance = await this.txeOracle.getContractDataProvider().getContractInstance(address);
-        return {
+        const instance = await this.contractStore.getContractInstance(address);
+        return instance && {
             ...instance,
             address
         };
@@ -59,30 +55,13 @@ export class TXEPublicContractDataSource {
         throw new Error('Method not implemented.');
     }
     async getContractArtifact(address) {
-        const instance = await this.txeOracle.getContractDataProvider().getContractInstance(address);
-        return this.txeOracle.getContractDataProvider().getContractArtifact(instance.currentContractClassId);
-    }
-    async getContractFunctionName(address, selector) {
-        const artifact = await this.getContractArtifact(address);
-        if (!artifact) {
-            return undefined;
-        }
-        const functionSelectorsAndNames = await Promise.all(artifact.functions.map(async (f)=>({
-                name: f.name,
-                selector: await FunctionSelector.fromNameAndParameters({
-                    name: f.name,
-                    parameters: f.parameters
-                })
-            })));
-        const func = functionSelectorsAndNames.find((f)=>f.selector.equals(selector));
-        return Promise.resolve(func?.name);
+        const instance = await this.contractStore.getContractInstance(address);
+        return instance && this.contractStore.getContractArtifact(instance.currentContractClassId);
     }
-    registerContractFunctionSignatures(_address, _signatures) {
-        return Promise.resolve();
+    async getDebugFunctionName(address, selector) {
+        return await this.contractStore.getDebugFunctionName(address, selector);
     }
-    // TODO(#10007): Remove this method.
-    addContractClass(_contractClass) {
-        // We don't really need to do anything for the txe here
+    registerContractFunctionSignatures(_signatures) {
         return Promise.resolve();
     }
 }

package/dest/utils/block_creation.d.ts

@@ -0,0 +1,28 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { L2Block } from '@aztec/stdlib/block';
+import { type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { BlockHeader, GlobalVariables, TxEffect } from '@aztec/stdlib/tx';
+/**
+ * Returns a transaction request hash that is valid for transactions that are the only ones in a block.
+ * @param blockNumber The number for the block in which there is a single transaction.
+ * @returns The transaction request hash.
+ */
+export declare function getSingleTxBlockRequestHash(blockNumber: BlockNumber): Fr;
+export declare function insertTxEffectIntoWorldTrees(txEffect: TxEffect, worldTrees: MerkleTreeWriteOperations): Promise<void>;
+export declare function makeTXEBlockHeader(worldTrees: MerkleTreeWriteOperations, globalVariables: GlobalVariables): Promise<BlockHeader>;
+/**
+ * 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
+ * 3. Updates the archive tree with the header hash
+ * 4. Gets the new archive state for the block's archive
+ *
+ * @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 L2Block with proper archive chaining
+ */
+export declare function makeTXEBlock(worldTrees: MerkleTreeWriteOperations, globalVariables: GlobalVariables, txEffects: TxEffect[]): Promise<L2Block>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2tfY3JlYXRpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9ibG9ja19jcmVhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQSxPQUFPLEVBQUUsV0FBVyxFQUEyQyxNQUFNLGlDQUFpQyxDQUFDO0FBRXZHLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQVEsT0FBTyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUF3QyxLQUFLLHlCQUF5QixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDM0csT0FBTyxFQUFFLFdBQVcsRUFBRSxlQUFlLEVBQUUsUUFBUSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFMUU7Ozs7R0FJRztBQUNILHdCQUFnQiwyQkFBMkIsQ0FBQyxXQUFXLEVBQUUsV0FBVyxHQUFHLEVBQUUsQ0FFeEU7QUFFRCx3QkFBc0IsNEJBQTRCLENBQ2hELFFBQVEsRUFBRSxRQUFRLEVBQ2xCLFVBQVUsRUFBRSx5QkFBeUIsR0FDcEMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQWtCZjtBQUVELHdCQUFzQixrQkFBa0IsQ0FDdEMsVUFBVSxFQUFFLHlCQUF5QixFQUNyQyxlQUFlLEVBQUUsZUFBZSxHQUMvQixPQUFPLENBQUMsV0FBVyxDQUFDLENBWXRCO0FBRUQ7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQXNCLFlBQVksQ0FDaEMsVUFBVSxFQUFFLHlCQUF5QixFQUNyQyxlQUFlLEVBQUUsZUFBZSxFQUNoQyxTQUFTLEVBQUUsUUFBUSxFQUFFLEdBQ3BCLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FlbEIifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"block_creation.d.ts","sourceRoot":"","sources":["../../src/utils/block_creation.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAA2C,MAAM,iCAAiC,CAAC;AAEvG,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAQ,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAwC,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC3G,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE1E;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,WAAW,GAAG,EAAE,CAExE;AAED,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,yBAAyB,GACpC,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,yBAAyB,EACrC,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,WAAW,CAAC,CAYtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,yBAAyB,EACrC,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,QAAQ,EAAE,GACpB,OAAO,CAAC,OAAO,CAAC,CAelB"}

package/dest/utils/block_creation.js

@@ -0,0 +1,56 @@
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Body, L2Block } from '@aztec/stdlib/block';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { BlockHeader } from '@aztec/stdlib/tx';
+/**
+ * Returns a transaction request hash that is valid for transactions that are the only ones in a block.
+ * @param blockNumber The number for the block in which there is a single transaction.
+ * @returns The transaction request hash.
+ */ 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) {
+    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));
+// We do not need to add public data writes because we apply them as we go.
+}
+export async function makeTXEBlockHeader(worldTrees, globalVariables) {
+    const stateReference = await worldTrees.getStateReference();
+    const archiveInfo = await worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
+    return BlockHeader.from({
+        lastArchive: new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)),
+        spongeBlobHash: Fr.ZERO,
+        state: stateReference,
+        globalVariables,
+        totalFees: Fr.ZERO,
+        totalManaUsed: Fr.ZERO
+    });
+}
+/**
+ * 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
+ * 3. Updates the archive tree with the header hash
+ * 4. Gets the new archive state for the block's archive
+ *
+ * @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 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
+    await worldTrees.updateArchive(header);
+    // 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));
+    // L2Block requires checkpointNumber and indexWithinCheckpoint
+    const checkpointNumber = CheckpointNumber.fromBlockNumber(globalVariables.blockNumber);
+    const indexWithinCheckpoint = IndexWithinCheckpoint(0);
+    return new L2Block(newArchive, header, new Body(txEffects), checkpointNumber, indexWithinCheckpoint);
+}

package/dest/utils/tx_effect_creation.d.ts

@@ -0,0 +1,5 @@
+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=

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

@@ -0,0 +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"}

package/dest/utils/tx_effect_creation.js

@@ -0,0 +1,13 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@aztec/stdlib/hash';
+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
+    txEffect.nullifiers = noteCache.getAllNullifiers();
+    txEffect.txHash = new TxHash(new Fr(txBlockNumber));
+    return txEffect;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/txe",
-  "version": "0.0.0-test.1",
+  "version": "0.0.1-commit.0b941701",
   "type": "module",
   "exports": "./dest/index.js",
   "bin": "./dest/bin/index.js",
@@ -12,13 +12,11 @@
     "tsconfig": "./tsconfig.json"
   },
   "scripts": {
-    "build": "yarn clean && tsc -b",
-    "build:dev": "tsc -b --watch",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
-    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
-    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
-    "dev": "LOG_LEVEL=debug node ./dest/bin/index.js",
+    "dev": "LOG_LEVEL=\"debug; trace: simulator:state_manager; info: json-rpc:proxy\" node ./dest/bin/index.js",
     "start": "node --no-warnings ./dest/bin/index.js"
   },
   "inherits": [
@@ -56,30 +54,38 @@
     "testTimeout": 120000,
     "setupFiles": [
       "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
     ]
   },
   "dependencies": {
-    "@aztec/accounts": "0.0.0-test.1",
-    "@aztec/aztec.js": "0.0.0-test.1",
-    "@aztec/constants": "0.0.0-test.1",
-    "@aztec/foundation": "0.0.0-test.1",
-    "@aztec/key-store": "0.0.0-test.1",
-    "@aztec/kv-store": "0.0.0-test.1",
-    "@aztec/protocol-contracts": "0.0.0-test.1",
-    "@aztec/pxe": "0.0.0-test.1",
-    "@aztec/simulator": "0.0.0-test.1",
-    "@aztec/stdlib": "0.0.0-test.1",
-    "@aztec/world-state": "0.0.0-test.1",
+    "@aztec/accounts": "0.0.1-commit.0b941701",
+    "@aztec/archiver": "0.0.1-commit.0b941701",
+    "@aztec/aztec-node": "0.0.1-commit.0b941701",
+    "@aztec/aztec.js": "0.0.1-commit.0b941701",
+    "@aztec/bb-prover": "0.0.1-commit.0b941701",
+    "@aztec/constants": "0.0.1-commit.0b941701",
+    "@aztec/foundation": "0.0.1-commit.0b941701",
+    "@aztec/key-store": "0.0.1-commit.0b941701",
+    "@aztec/kv-store": "0.0.1-commit.0b941701",
+    "@aztec/protocol-contracts": "0.0.1-commit.0b941701",
+    "@aztec/pxe": "0.0.1-commit.0b941701",
+    "@aztec/simulator": "0.0.1-commit.0b941701",
+    "@aztec/stdlib": "0.0.1-commit.0b941701",
+    "@aztec/world-state": "0.0.1-commit.0b941701",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.0",
-    "@types/node": "^18.7.23",
-    "jest": "^29.5.0",
-    "jest-mock-extended": "^3.0.3",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.3.3"
   },
   "files": [
     "dest",
@@ -88,6 +94,6 @@
   ],
   "types": "./dest/index.d.ts",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/bin/index.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env -S node --no-warnings
-import { createLogger } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/aztec.js/log';
 import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
 
 import { createTXERpcServer } from '../index.js';
@@ -20,11 +20,12 @@ async function main() {
     process.exit(0);
   });
 
-  const logger = createLogger('txe:service');
+  const logger = createLogger('txe:rpc');
   logger.info(`Setting up TXE...`);
 
   const txeServer = createTXERpcServer(logger);
   const { port } = await startHttpRpcServer(txeServer, {
+    host: '127.0.0.1',
     port: TXE_PORT,
     timeoutMs: 1e3 * 60 * 5,
   });

package/src/constants.ts

@@ -0,0 +1,3 @@
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+export const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);