@aztec/txe 0.0.1-commit.3100065 → 0.0.1-commit.330febf

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/txe",
-  "version": "0.0.1-commit.3100065",
+  "version": "0.0.1-commit.330febf",
   "type": "module",
   "exports": {
     "./server": {
@@ -69,22 +69,22 @@
     ]
   },
   "dependencies": {
-    "@aztec/accounts": "0.0.1-commit.3100065",
-    "@aztec/archiver": "0.0.1-commit.3100065",
-    "@aztec/aztec-node": "0.0.1-commit.3100065",
-    "@aztec/aztec.js": "0.0.1-commit.3100065",
-    "@aztec/bb-prover": "0.0.1-commit.3100065",
-    "@aztec/bb.js": "0.0.1-commit.3100065",
-    "@aztec/constants": "0.0.1-commit.3100065",
-    "@aztec/foundation": "0.0.1-commit.3100065",
-    "@aztec/key-store": "0.0.1-commit.3100065",
-    "@aztec/kv-store": "0.0.1-commit.3100065",
-    "@aztec/protocol-contracts": "0.0.1-commit.3100065",
-    "@aztec/pxe": "0.0.1-commit.3100065",
-    "@aztec/simulator": "0.0.1-commit.3100065",
-    "@aztec/standard-contracts": "0.0.1-commit.3100065",
-    "@aztec/stdlib": "0.0.1-commit.3100065",
-    "@aztec/world-state": "0.0.1-commit.3100065",
+    "@aztec/accounts": "0.0.1-commit.330febf",
+    "@aztec/archiver": "0.0.1-commit.330febf",
+    "@aztec/aztec-node": "0.0.1-commit.330febf",
+    "@aztec/aztec.js": "0.0.1-commit.330febf",
+    "@aztec/bb-prover": "0.0.1-commit.330febf",
+    "@aztec/bb.js": "6.0.0-nightly.20260807",
+    "@aztec/constants": "0.0.1-commit.330febf",
+    "@aztec/foundation": "0.0.1-commit.330febf",
+    "@aztec/key-store": "0.0.1-commit.330febf",
+    "@aztec/kv-store": "0.0.1-commit.330febf",
+    "@aztec/protocol-contracts": "0.0.1-commit.330febf",
+    "@aztec/pxe": "0.0.1-commit.330febf",
+    "@aztec/simulator": "0.0.1-commit.330febf",
+    "@aztec/standard-contracts": "0.0.1-commit.330febf",
+    "@aztec/stdlib": "0.0.1-commit.330febf",
+    "@aztec/world-state": "0.0.1-commit.330febf",
     "msgpackr": "^1.11.2",
     "zod": "^4"
   },

package/src/bin/check_txe_oracle_version.ts

@@ -1,32 +1,26 @@
 import { keccak256String } from '@aztec/foundation/crypto/keccak';
-import { getOracleInterfaceSignature, readNumericGlobal } from '@aztec/pxe/bin';
+import { getOracleRegistrySignature } from '@aztec/pxe/bin';
+import { ORACLE_REGISTRY, type OracleRegistryEntry } from '@aztec/pxe/simulator';
 
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-
-import { TXE_ORACLE_INTERFACE_HASH, TXE_ORACLE_VERSION_MAJOR } from '../oracle/txe_oracle_version.js';
+import { TXE_ORACLE_REGISTRY } from '../oracle/txe_oracle_registry.js';
+import { TXE_ORACLE_INTERFACE_HASH } from '../oracle/txe_oracle_version.js';
 
 /**
  * Verifies that the TXE oracle interfaces match the expected interface hash.
  *
  * The TXE oracle interfaces need to be versioned to ensure compatibility between Aztec.nr tests and TXE. This function
- * computes a hash of the TXE oracle interfaces and compares it against a known hash. If they don't match, it means an
+ * computes a hash of the TXE-specific entries in `TXE_ORACLE_REGISTRY` (the shared PXE entries are covered by the PXE
+ * oracle version check) and compares it against a known hash. If they don't match, it means an
  * interface has changed and the TXE oracle version needs to be bumped:
  *   - If the change is backward-breaking (e.g. removing/renaming an oracle), bump TXE_ORACLE_VERSION_MAJOR.
  *   - If the change is an oracle addition (non-breaking), bump TXE_ORACLE_VERSION_MINOR.
  */
 function assertTxeOracleInterfaceMatches(): void {
-  const currentDir = dirname(fileURLToPath(import.meta.url));
-  const packageRoot = dirname(dirname(currentDir));
-  const interfacesSourcePath = join(packageRoot, 'src/oracle/interfaces.ts');
-
-  const targets = ['IAvmExecutionOracle', 'ITxeExecutionOracle'];
-  // Not an oracle foreign call handler (see TODO(F-335) in interfaces.ts).
-  const excludedMembers = ['syncContractNonOracleMethod'];
-
-  const txeOracleInterfaceSignature = getOracleInterfaceSignature(interfacesSourcePath, targets, excludedMembers);
+  const txeOnlyEntries: Record<string, OracleRegistryEntry> = Object.fromEntries(
+    Object.entries(TXE_ORACLE_REGISTRY).filter(([name]) => !(name in ORACLE_REGISTRY)),
+  );
 
-  const txeOracleInterfaceHash = keccak256String(txeOracleInterfaceSignature);
+  const txeOracleInterfaceHash = keccak256String(getOracleRegistrySignature(txeOnlyEntries));
   if (txeOracleInterfaceHash !== TXE_ORACLE_INTERFACE_HASH) {
     throw new Error(
       `The TXE oracle interface has changed. Update TXE_ORACLE_INTERFACE_HASH to ${txeOracleInterfaceHash} in txe/src/oracle/txe_oracle_version.ts and bump the TXE oracle version (TXE_ORACLE_VERSION_MAJOR for breaking changes, TXE_ORACLE_VERSION_MINOR for oracle additions).`,
@@ -34,37 +28,4 @@ function assertTxeOracleInterfaceMatches(): void {
   }
 }
 
-/**
- * Verifies that `TXE_ORACLE_VERSION_MAJOR` is identical across its two hand-maintained copies: the TXE TypeScript
- * constant and the Aztec.nr Noir test helper constant. These layers can't import each other, so the major version is
- * duplicated by hand and a mismatch otherwise only surfaces at runtime. This is the TXE counterpart of the contract
- * oracle version check in `pxe/src/bin/check_oracle_version.ts`; the two version families are tracked separately.
- *
- * Only the major version is checked: the minor version legitimately diverges under the "environment minor >= contract
- * minor" tolerance, so asserting minor equality would false-positive.
- */
-function assertTxeOracleVersionMajorInSync(): void {
-  const currentDir = dirname(fileURLToPath(import.meta.url));
-  // Go up from dest/bin/ or src/bin/ to the package root (txe/), then up two more to the git root.
-  const packageRoot = dirname(dirname(currentDir));
-  const gitRoot = join(packageRoot, '..', '..');
-
-  const copies = [
-    { label: 'txe/src/txe_oracle_version.ts', value: TXE_ORACLE_VERSION_MAJOR },
-    {
-      label: 'aztec-nr/aztec/src/test/helpers/txe_oracles.nr',
-      value: readNumericGlobal(
-        join(gitRoot, 'noir-projects/aztec-nr/aztec/src/test/helpers/txe_oracles.nr'),
-        'TXE_ORACLE_VERSION_MAJOR',
-      ),
-    },
-  ];
-
-  if (new Set(copies.map(copy => copy.value)).size > 1) {
-    const details = copies.map(copy => `${copy.label}=${copy.value}`).join(', ');
-    throw new Error(`TXE_ORACLE_VERSION_MAJOR is out of sync: ${details}. Bump all copies together.`);
-  }
-}
-
 assertTxeOracleInterfaceMatches();
-assertTxeOracleVersionMajorInSync();

package/src/constants.ts

@@ -9,5 +9,5 @@ export const MAX_PRIVATE_EVENTS_PER_TXE_QUERY = 5;
 
 // Arbitrarily set at 64 because we need a bound. Nothing inherent about it.
 export const MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY = 64;
-// Must match MAX_OFFCHAIN_EFFECT_LEN in noir-projects/aztec-nr/aztec/src/test/helpers/txe_oracles.nr.
+// Must match MAX_OFFCHAIN_EFFECT_LEN in noir-projects/labs/aztec-nr/aztec/src/test/helpers/txe_oracles.nr.
 export const MAX_OFFCHAIN_EFFECT_LEN = 2 + PRIVATE_LOG_CIPHERTEXT_LEN;

package/src/oracle/interfaces.ts

@@ -69,7 +69,7 @@ export interface ITxeExecutionOracle {
     salt: Fr,
     deployer: AztecAddress,
   ): Promise<Fr[]>;
-  createAccount(secret: Fr): Promise<CompleteAddress>;
+  createAccount(secret: Fr, partialAddress: Fr): Promise<CompleteAddress>;
   addAccount(secret: Fr): Promise<CompleteAddress>;
   addAuthWitness(address: AztecAddress, messageHash: Fr): Promise<void>;
   sendL1ToL2Message(content: Fr, secretHash: Fr, sender: EthAddress, recipient: AztecAddress): Promise<Fr>;
@@ -81,6 +81,10 @@ export interface ITxeExecutionOracle {
     unconstrainedStrategy: Option<TaggingSecretStrategy>,
     constrainedStrategy: Option<TaggingSecretStrategy>,
   ): void;
+  /**
+   * Configures whether the test's simulated wallet authorizes every cross-contract utility call target.
+   */
+  setAuthorizeAllUtilityCallTargets(authorizeAll: boolean): void;
   getLastBlockTimestamp(): Promise<bigint>;
   getLastTxEffects(): Promise<{
     txHash: TxHash;

package/src/oracle/test-resolver/default_fixtures.ts

@@ -8,19 +8,29 @@ import {
   BLOCK_HASH,
   BLOCK_NUMBER,
   BOOL,
-  BYTE,
   BoundedVec,
+  type CompositeMapping,
   DELIVERY_MODE,
   ETH_ADDRESS,
   FIELD,
   FUNCTION_SELECTOR,
+  LEAF_INDEX,
   NOTE_SELECTOR,
   Option,
   type OracleRegistryEntry,
   SLOT_NUMBER,
-  type StructField,
+  type StructMapping,
   type TypeMapping,
+  U8,
   U32,
+  U64,
+  U128,
+  isArrayMapping,
+  isBoundedVecMapping,
+  isFixedArrayMapping,
+  isFixedBoundedVecMapping,
+  isOptionMapping,
+  isStructMapping,
   tryFieldWidth,
 } from '@aztec/pxe/simulator';
 import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
@@ -50,15 +60,18 @@ export function synthesizeDefaultFixtures(
 }
 
 /**
- * The test-value implementations, one per oracle type, mirroring the Noir synthesizer tables (`scalars` and
- * `synthesizers` in `noir-projects/aztec-nr/.../macros/oracle_testing.nr`) exactly.
+ * The scalar test-value implementations, mirroring the Noir synthesizer's `scalars` table in
+ * `noir-projects/labs/aztec-nr/.../macros/oracle_testing.nr` exactly.
  */
-const TEST_VALUE_IMPLS: TestValueImpl[] = [
+const SCALAR_IMPLS: ScalarImpl[] = [
   scalar(FIELD, seed => new Fr(seed)),
   scalar(U32, seed => seed),
   scalar(BLOCK_NUMBER, seed => BlockNumber(seed)),
   scalar(BIGINT, seed => BigInt(seed)),
-  scalar(BYTE, seed => seed),
+  scalar(U64, seed => BigInt(seed)),
+  scalar(U128, seed => BigInt(seed)),
+  scalar(LEAF_INDEX, seed => seed),
+  scalar(U8, seed => seed),
   scalar(BOOL, seed => seed % 2 !== 0),
   scalar(AZTEC_ADDRESS, seed => AztecAddress.fromNumberUnsafe(seed)),
   scalar(ETH_ADDRESS, seed => EthAddress.fromField(new Fr(seed))),
@@ -70,12 +83,18 @@ const TEST_VALUE_IMPLS: TestValueImpl[] = [
   scalar(DELIVERY_MODE, seed =>
     seed % 2 === 0 ? AppTaggingSecretKind.UNCONSTRAINED : AppTaggingSecretKind.CONSTRAINED,
   ),
-  composite(isOption, (type, seed) => [
-    named(Option.some(firstValue(type.inner, seed)), 'some'),
-    named(Option.none(firstValue(type.inner, seed)), 'none'),
+];
+
+/**
+ * The composite test-value implementations, one per combinator, mirroring the Noir synthesizer's `synthesizers` table.
+ */
+const COMPOSITE_IMPLS: CompositeImpl[] = [
+  composite(isOptionMapping, (type, seed) => [
+    named(Option.some(testValueFor(type.inner, seed)), 'some'),
+    named(Option.none(testValueFor(type.inner, seed)), 'none'),
   ]),
-  composite(isArray, (type, seed) => [unnamed(collectionData(type.inner, seed, DEFAULT_ARRAY_LENGTH))]),
-  composite(isBoundedVec, (type, seed) => [
+  composite(isArrayMapping, (type, seed) => [unnamed(collectionData(type.inner, seed, DEFAULT_ARRAY_LENGTH))]),
+  composite(isBoundedVecMapping, (type, seed) => [
     unnamed(
       BoundedVec.from({
         data: collectionData(type.inner, seed, DEFAULT_ARRAY_LENGTH),
@@ -83,17 +102,20 @@ const TEST_VALUE_IMPLS: TestValueImpl[] = [
       }),
     ),
   ]),
-  composite(isStruct, (type, seed) => [unnamed(structValue(type, seed))]),
+  composite(isStructMapping, (type, seed) => [unnamed(structValue(type, seed))]),
   // A fixed-length array uses its real (signature) length, unlike the generic-length ARRAY which is pinned to
   // DEFAULT_ARRAY_LENGTH.
-  composite(isFixedArray, (type, seed) => [unnamed(collectionData(type.inner, seed, type.length))]),
+  composite(isFixedArrayMapping, (type, seed) => [unnamed(collectionData(type.inner, seed, type.length))]),
   // Same for a fixed-capacity bounded vec: real capacity, DEFAULT_ARRAY_LENGTH elements (its value type is a plain
   // element array, unlike the two-slot BOUNDED_VEC), clamped to the capacity so small vecs stay valid.
-  composite(isFixedBoundedVec, (type, seed) => [
+  composite(isFixedBoundedVecMapping, (type, seed) => [
     unnamed(collectionData(type.inner, seed, Math.min(DEFAULT_ARRAY_LENGTH, type.maxLength))),
   ]),
 ];
 
+/** The scalar mappings with a registered test-value impl. */
+export const SCALAR_MAPPINGS: TypeMapping<any>[] = SCALAR_IMPLS.map(impl => impl.mapping);
+
 /**
  * The base every seed is offset by, applied once where a parameter's position becomes its seed, so generated values
  * stay clear of 0. Must match `SEED_BASE` in the Noir `oracle_testing.nr`.
@@ -125,32 +147,34 @@ function named(value: unknown, name: string): Scenario {
   return { value, name };
 }
 
-/**
- * One type's test-value implementation, mirroring a Noir `TestValueSynthesizer` entry: `match` selects the type and
- * `scenarios` yields its [`Scenario`]s for `seed`, one per serialization shape, like the Noir entry's `scenarios`
- * function.
- */
-interface TestValueImpl {
+/** An impl for the single scalar `mapping` it synthesizes for. */
+type ScalarImpl = {
+  mapping: TypeMapping<any>;
+  scenarios: (type: TypeMapping<any>, seed: number) => Scenario[];
+};
+
+/** An impl for a whole family of composite mappings, selected by its `kind` type guard. */
+type CompositeImpl = {
   match: (type: TypeMapping<any>) => boolean;
   scenarios: (type: TypeMapping<any>, seed: number) => Scenario[];
-}
+};
 
-/** A scalar impl: matches the singleton `type` by identity and yields a single unnamed scenario. */
-function scalar(type: TypeMapping<any>, value: (seed: number) => unknown): TestValueImpl {
-  return { match: t => t === type, scenarios: (_type, seed) => [unnamed(value(seed))] };
+/** A scalar impl yielding a single unnamed scenario. */
+function scalar(mapping: TypeMapping<any>, value: (seed: number) => unknown): ScalarImpl {
+  return { mapping, scenarios: (_type, seed) => [unnamed(value(seed))] };
 }
 
-/** A composite impl: selected by the `kind` type guard, recursing through its element/inner mapping. */
+/** A composite impl, recursing through the matched mapping's element/inner mapping. */
 function composite<K extends CompositeMapping>(
   guard: (type: TypeMapping<any>) => type is K,
   scenarios: (type: K, seed: number) => Scenario[],
-): TestValueImpl {
+): CompositeImpl {
   return { match: guard, scenarios: (type, seed) => scenarios(type as K, seed) };
 }
 
 /** Synthesized element values for a collection. */
 function collectionData(element: TypeMapping<any>, seed: number, length: number): unknown[] {
-  return Array.from({ length }, (_, i) => firstValue(element, seed + i));
+  return Array.from({ length }, (_, i) => testValueFor(element, seed + i));
 }
 
 /**
@@ -161,7 +185,7 @@ function structValue(type: StructMapping, seed: number): Record<string, unknown>
   const value: Record<string, unknown> = {};
   let offset = 0;
   for (const field of type.fields) {
-    value[field.name] = firstValue(field.type, seed + offset);
+    value[field.name] = testValueFor(field.type, seed + offset);
     const width = tryFieldWidth(field.type.shape);
     if (width === undefined) {
       // A variable-width field has no flat offset to seed the next field at, so only this oracle is unsynthesizable.
@@ -177,15 +201,18 @@ function structValue(type: StructMapping, seed: number): Record<string, unknown>
  * dispatcher. Throws if the type has no matching impl.
  */
 function scenariosForType(type: TypeMapping<any>, seed: number): Scenario[] {
-  const impl = TEST_VALUE_IMPLS.find(i => i.match(type));
+  const impl = SCALAR_IMPLS.find(i => i.mapping === type) ?? COMPOSITE_IMPLS.find(i => i.match(type));
   if (!impl) {
     throw new UnsynthesizableTypeError(type);
   }
   return impl.scenarios(type, seed);
 }
 
-/** The first (representative) test value of `type`, used for collection elements and `Option` inners. */
-function firstValue(type: TypeMapping<any>, seed: number): unknown {
+/**
+ * The test value of `type` at `seed`, matching what the Noir synthesizer produces for the same type and seed. Throws
+ * for types without a test-value impl.
+ */
+export function testValueFor(type: TypeMapping<any>, seed: number): unknown {
   return scenariosForType(type, seed)[0].value;
 }
 
@@ -242,41 +269,3 @@ function synthesizeScenariosOrThrow(entry: OracleRegistryEntry): OracleTestScena
   }
   return scenarios;
 }
-
-/**
- * The composite `TypeMapping`s (`ARRAY`/`BOUNDED_VEC`/`OPTION`/`STRUCT`/`FIXED_ARRAY`/`FIXED_BOUNDED_VEC`),
- * discriminated by `kind`. The combinators attach `kind` plus the inner mapping(s) at construction; the registry
- * erases params to the base `TypeMapping`, so the guards below recover the structure for recursion.
- */
-type ArrayMapping = TypeMapping & { kind: 'array'; inner: TypeMapping };
-type BoundedVecMapping = TypeMapping & { kind: 'bounded-vec'; inner: TypeMapping };
-type OptionMapping = TypeMapping & { kind: 'option'; inner: TypeMapping };
-type StructMapping = TypeMapping & { kind: 'struct'; fields: readonly StructField[] };
-type FixedArrayMapping = TypeMapping & { kind: 'fixed-array'; inner: TypeMapping; length: number };
-type FixedBoundedVecMapping = TypeMapping & { kind: 'fixed-bounded-vec'; inner: TypeMapping; maxLength: number };
-type CompositeMapping =
-  | ArrayMapping
-  | BoundedVecMapping
-  | OptionMapping
-  | StructMapping
-  | FixedArrayMapping
-  | FixedBoundedVecMapping;
-
-function isArray(type: TypeMapping<any>): type is ArrayMapping {
-  return 'kind' in type && type.kind === 'array';
-}
-function isBoundedVec(type: TypeMapping<any>): type is BoundedVecMapping {
-  return 'kind' in type && type.kind === 'bounded-vec';
-}
-function isOption(type: TypeMapping<any>): type is OptionMapping {
-  return 'kind' in type && type.kind === 'option';
-}
-function isStruct(type: TypeMapping<any>): type is StructMapping {
-  return 'kind' in type && type.kind === 'struct';
-}
-function isFixedArray(type: TypeMapping<any>): type is FixedArrayMapping {
-  return 'kind' in type && type.kind === 'fixed-array';
-}
-function isFixedBoundedVec(type: TypeMapping<any>): type is FixedBoundedVecMapping {
-  return 'kind' in type && type.kind === 'fixed-bounded-vec';
-}

package/src/oracle/test-resolver/resolver.ts

@@ -2,7 +2,7 @@
 import type { Logger } from '@aztec/foundation/log';
 import { createLogger } from '@aztec/foundation/log';
 import { withoutHexPrefix } from '@aztec/foundation/string';
-import { BOUNDED_VEC, BYTE, BoundedVec, Option, type OracleRegistryEntry, makeEntry } from '@aztec/pxe/simulator';
+import { BOUNDED_VEC, BoundedVec, Option, type OracleRegistryEntry, U8, makeEntry } from '@aztec/pxe/simulator';
 
 import type { ForeignCallArgs, ForeignCallResult } from '../../utils/encoding.js';
 import { toInputSlots } from '../txe_oracle_registry.js';
@@ -10,7 +10,7 @@ import { synthesizeDefaultFixtures } from './default_fixtures.js';
 
 /** Name of the meta-oracle that Noir tests call to announce the next call's scenario by name. */
 const SET_SCENARIO_ORACLE = 'aztec_oracle_test_set_scenario';
-export const SET_SCENARIO_ENTRY = makeEntry({ params: [{ name: 'name', type: BOUNDED_VEC(BYTE) }] });
+export const SET_SCENARIO_ENTRY = makeEntry({ params: [{ name: 'name', type: BOUNDED_VEC(U8) }] });
 
 export type OracleTestCallInput = {
   session_id: number;

package/src/oracle/txe_oracle_registry.ts

@@ -14,7 +14,6 @@ import type { TaggingSecretStrategy } from '@aztec/pxe/server';
 import {
   ARRAY,
   AZTEC_ADDRESS,
-  BIGINT,
   BLOCK_NUMBER,
   BOOL,
   ETH_ADDRESS,
@@ -22,17 +21,20 @@ import {
   FIXED_ARRAY,
   FUNCTION_SELECTOR,
   type InputSlot,
+  LEAF,
   type MaybePromise,
   OPTION,
   ORACLE_REGISTRY,
   type OracleRegistryEntry,
   type OutputSlot,
   type ParamTypes,
+  SCALAR,
   STR,
   STRUCT,
   type SlotShape,
   type TypeMapping,
   U32,
+  U64,
   buildACIRCallback,
   makeEntry,
 } from '@aztec/pxe/simulator';
@@ -59,12 +61,13 @@ export type { BlockHash } from '@aztec/stdlib/block';
 export type { MembershipWitness } from '@aztec/foundation/trees';
 export type { NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 
-const GAS_SETTINGS: TypeMapping<GasSettings> = {
+const GAS_SETTINGS: TypeMapping<GasSettings> = LEAF({
+  kind: 'gas-settings',
   deserialization: {
     fn: ([reader]) => GasSettings.fromFields(reader.readFieldArray(GAS_SETTINGS_LENGTH)),
   },
   shape: [{ len: GAS_SETTINGS_LENGTH }],
-};
+});
 
 // Tagging secret strategy discriminants. Must match the Noir test helper `TaggingSecretStrategy` in
 // aztec-nr `test/helpers/tagging_secret_strategy.nr`. This is a test-only oracle (only `set_tagging_secret_strategies`
@@ -74,7 +77,8 @@ const STRATEGY_ARBITRARY_SECRET = 2;
 const STRATEGY_ADDRESS_DERIVED = 3;
 const STRATEGY_INTERACTIVE_HANDSHAKE = 4;
 
-const TAGGING_SECRET_STRATEGY: TypeMapping<TaggingSecretStrategy> = {
+const TAGGING_SECRET_STRATEGY: TypeMapping<TaggingSecretStrategy> = LEAF({
+  kind: 'tagging-secret-strategy',
   serialization: {
     fn: strategy => {
       switch (strategy.type) {
@@ -108,24 +112,27 @@ const TAGGING_SECRET_STRATEGY: TypeMapping<TaggingSecretStrategy> = {
     },
   },
   shape: ['scalar', 'scalar', 'scalar'],
-};
+});
 
-const PRIVATE_CONTEXT_INPUTS: TypeMapping<PrivateContextInputs> = {
+const PRIVATE_CONTEXT_INPUTS: TypeMapping<PrivateContextInputs> = LEAF({
+  kind: 'private-context-inputs',
   serialization: { fn: v => v.toFields() },
   shape: Array<SlotShape>(PRIVATE_CONTEXT_INPUTS_LENGTH).fill('scalar'),
-};
+});
 
-const COMPLETE_ADDRESS: TypeMapping<CompleteAddress> = {
+const COMPLETE_ADDRESS: TypeMapping<CompleteAddress> = LEAF({
+  kind: 'complete-address',
   serialization: { fn: v => [v.address.toField(), ...v.publicKeys.toFields()] },
   shape: Array<SlotShape>(8).fill('scalar'), // address + 7 public-key fields
-};
+});
 
 const TXE_TX_EFFECTS: TypeMapping<{
   txHash: TxHash;
   noteHashes: Fr[];
   nullifiers: Fr[];
   privateLogs: PrivateLog[];
-}> = {
+}> = LEAF({
+  kind: 'txe-tx-effects',
   serialization: {
     fn: ({ txHash, noteHashes, nullifiers, privateLogs }) => {
       const emittedLogs = privateLogs.map(log => log.getEmittedFields());
@@ -164,9 +171,10 @@ const TXE_TX_EFFECTS: TypeMapping<{
     { len: MAX_PRIVATE_LOGS_PER_TX },
     'scalar',
   ],
-};
+});
 
-const TXE_OFFCHAIN_EFFECTS: TypeMapping<{ effects: Fr[][] }> = {
+const TXE_OFFCHAIN_EFFECTS: TypeMapping<{ effects: Fr[][] }> = LEAF({
+  kind: 'txe-offchain-effects',
   serialization: {
     fn: ({ effects }) => {
       const rawArrayStorage = effects
@@ -188,9 +196,10 @@ const TXE_OFFCHAIN_EFFECTS: TypeMapping<{ effects: Fr[][] }> = {
     { len: MAX_OFFCHAIN_EFFECTS_PER_TXE_QUERY },
     'scalar',
   ],
-};
+});
 
-const TXE_CALL_CONTEXT: TypeMapping<{ txHash: Fr; anchorBlockTimestamp: bigint }> = {
+const TXE_CALL_CONTEXT: TypeMapping<{ txHash: Fr; anchorBlockTimestamp: bigint }> = LEAF({
+  kind: 'txe-call-context',
   serialization: {
     fn: ({ txHash, anchorBlockTimestamp }) => {
       const isSome = txHash.isZero() ? 0 : 1;
@@ -198,7 +207,7 @@ const TXE_CALL_CONTEXT: TypeMapping<{ txHash: Fr; anchorBlockTimestamp: bigint }
     },
   },
   shape: ['scalar', 'scalar', 'scalar'], // discriminant, txHash, anchor block timestamp
-};
+});
 
 const CONTRACT_INSTANCE_MEMBER: TypeMapping<{ exists: boolean; member: Fr }[]> = FIXED_ARRAY(
   STRUCT([
@@ -208,13 +217,14 @@ const CONTRACT_INSTANCE_MEMBER: TypeMapping<{ exists: boolean; member: Fr }[]> =
   1,
 );
 
-const EVENT_SELECTOR: TypeMapping<EventSelector> = {
+const EVENT_SELECTOR: TypeMapping<EventSelector> = SCALAR({
+  kind: 'event-selector',
   serialization: { fn: v => [v.toField()] },
   deserialization: { fn: ([reader]) => EventSelector.fromField(reader.readField()) },
-  shape: ['scalar'],
-};
+});
 
-const TXE_PRIVATE_EVENTS: TypeMapping<Fr[][]> = {
+const TXE_PRIVATE_EVENTS: TypeMapping<Fr[][]> = LEAF({
+  kind: 'txe-private-events',
   serialization: {
     fn: events => {
       const rawArrayStorage = events
@@ -235,7 +245,7 @@ const TXE_PRIVATE_EVENTS: TypeMapping<Fr[][]> = {
     { len: MAX_PRIVATE_EVENTS_PER_TXE_QUERY },
     'scalar',
   ],
-};
+});
 
 export const TXE_ORACLE_REGISTRY = {
   ...ORACLE_REGISTRY,
@@ -270,14 +280,14 @@ export const TXE_ORACLE_REGISTRY = {
 
   aztec_txe_getNextBlockNumber: makeEntry({ returnType: BLOCK_NUMBER }),
 
-  aztec_txe_getNextBlockTimestamp: makeEntry({ returnType: BIGINT }),
+  aztec_txe_getNextBlockTimestamp: makeEntry({ returnType: U64 }),
 
   aztec_txe_advanceBlocksBy: makeEntry({
     params: [{ name: 'blocks', type: U32 }],
   }),
 
   aztec_txe_advanceTimestampBy: makeEntry({
-    params: [{ name: 'duration', type: BIGINT }],
+    params: [{ name: 'duration', type: U64 }],
   }),
 
   aztec_txe_deploy: makeEntry({
@@ -294,7 +304,10 @@ export const TXE_ORACLE_REGISTRY = {
   }),
 
   aztec_txe_createAccount: makeEntry({
-    params: [{ name: 'secret', type: FIELD }],
+    params: [
+      { name: 'secret', type: FIELD },
+      { name: 'partialAddress', type: FIELD },
+    ],
     returnType: COMPLETE_ADDRESS,
   }),
 
@@ -327,8 +340,12 @@ export const TXE_ORACLE_REGISTRY = {
     ],
   }),
 
+  aztec_txe_setAuthorizeAllUtilityCallTargets: makeEntry({
+    params: [{ name: 'authorizeAll', type: BOOL }],
+  }),
+
   aztec_txe_getLastBlockTimestamp: makeEntry({
-    returnType: BIGINT,
+    returnType: U64,
   }),
 
   aztec_txe_getLastTxEffects: makeEntry({ returnType: TXE_TX_EFFECTS }),
@@ -387,7 +404,7 @@ export const TXE_ORACLE_REGISTRY = {
 
   aztec_avm_blockNumber: makeEntry({ returnType: BLOCK_NUMBER }),
 
-  aztec_avm_timestamp: makeEntry({ returnType: BIGINT }),
+  aztec_avm_timestamp: makeEntry({ returnType: U64 }),
 
   aztec_avm_isStaticCall: makeEntry({ returnType: BOOL }),