@aztec/pxe 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/src/contract_function_simulator/oracle/oracle_registry.ts

@@ -1,270 +1,106 @@
 /* eslint-disable camelcase */
-import {
-  ARCHIVE_HEIGHT,
-  BLOCK_HEADER_LENGTH,
-  KEY_VALIDATION_REQUEST_LENGTH,
-  L1_TO_L2_MSG_TREE_HEIGHT,
-  MAX_CONTRACT_CLASS_LOGS_PER_TX,
-  MAX_L2_TO_L1_MSGS_PER_TX,
-  MAX_NOTE_HASHES_PER_TX,
-  MAX_NULLIFIERS_PER_TX,
-  MAX_PRIVATE_LOGS_PER_TX,
-  MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  NOTE_HASH_TREE_HEIGHT,
-} from '@aztec/constants';
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { ARCHIVE_HEIGHT, NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
-import { MembershipWitness } from '@aztec/foundation/trees';
-import { type ACVMField, fromUintArray, toACVMField } from '@aztec/simulator/client';
-import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
-import { PublicDataWrite } from '@aztec/stdlib/avm';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { BlockHash } from '@aztec/stdlib/block';
-import type { ContractInstance, PartialAddress } from '@aztec/stdlib/contract';
-import { KeyValidationRequest } from '@aztec/stdlib/kernel';
-import type { PublicKeys } from '@aztec/stdlib/keys';
-import { ContractClassLog, ContractClassLogFields, FlatPublicLogs, PrivateLog, Tag } from '@aztec/stdlib/logs';
-import { NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
-import { BlockHeader, TxEffect, TxHash } from '@aztec/stdlib/tx';
-
-import { BoundedVec } from '../noir-structs/bounded_vec.js';
-import { Option } from '../noir-structs/option.js';
-import { UtilityContext } from '../noir-structs/utility_context.js';
-import type { NoteData } from './interfaces.js';
-import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
-import { packAsHintedNote } from './note_packing_utils.js';
-
-const FIELD: TypeMapping<Fr> = {
-  serialization: { fn: v => [v] },
-  deserialization: { fn: ([reader]) => reader.readField(), slots: 1 },
-};
-
-const BOOL: TypeMapping<boolean> = {
-  serialization: { fn: v => [new Fr(v ? 1n : 0n)] },
-  deserialization: { fn: ([reader]) => !reader.readField().isZero(), slots: 1 },
-};
-
-export const U32: TypeMapping<number> = {
-  serialization: { fn: v => [new Fr(v)] },
-  deserialization: {
-    fn: ([reader]) => {
-      const value = reader.readField().toBigInt();
-      if (value > 0xffffffffn) {
-        throw new Error(`U32 overflow: value ${value} exceeds u32 max (${0xffffffffn})`);
-      }
-      return Number(value);
-    },
-    slots: 1,
-  },
-};
-
-const BLOCK_NUMBER: TypeMapping<BlockNumber> = {
-  serialization: { fn: v => [new Fr(v)] },
-  deserialization: { fn: ([reader]) => BlockNumber(reader.readField().toNumber()), slots: 1 },
-};
-
-/** A u8 byte: serializes to a single Fr; deserializes from a single Fr to a number in [0, 255]. */
-export const BYTE: TypeMapping<number> = {
-  serialization: { fn: byte => [new Fr(byte)] },
-  deserialization: {
-    fn: ([reader]) => {
-      const value = reader.readField().toBigInt();
-      if (value > 0xffn) {
-        throw new Error(`BYTE overflow: value ${value} exceeds u8 max (255)`);
-      }
-      return Number(value);
-    },
-    slots: 1,
-  },
-};
-
-/** Reads every field in the slot as a UTF-8 character code. */
-const STR: TypeMapping<string> = {
-  serialization: { fn: str => [Array.from(Buffer.from(str, 'utf-8')).map(b => new Fr(b))] },
-  deserialization: {
-    fn: ([reader]) => {
-      const chars: string[] = [];
-      while (!reader.isFinished()) {
-        chars.push(String.fromCharCode(reader.readField().toNumber()));
-      }
-      return chars.join('');
-    },
-    slots: 1,
-  },
-};
-
-const AZTEC_ADDRESS: TypeMapping<AztecAddress> = {
-  serialization: { fn: v => [v.toField()] },
-  deserialization: { fn: ([reader]) => AztecAddress.fromField(reader.readField()), slots: 1 },
-};
-
-const BLOCK_HASH: TypeMapping<BlockHash> = {
-  serialization: { fn: v => [new Fr(v.toBuffer())] },
-  deserialization: { fn: ([reader]) => new BlockHash(reader.readField()), slots: 1 },
-};
-
-const FUNCTION_SELECTOR: TypeMapping<FunctionSelector> = {
-  serialization: { fn: v => [v.toField()] },
-  deserialization: { fn: ([reader]) => FunctionSelector.fromField(reader.readField()), slots: 1 },
-};
-
-const NOTE_SELECTOR: TypeMapping<NoteSelector> = {
-  serialization: { fn: v => [v.toField()] },
-  deserialization: { fn: ([reader]) => NoteSelector.fromField(reader.readField()), slots: 1 },
-};
-
-const TX_HASH: TypeMapping<TxHash> = {
-  serialization: { fn: v => [v.hash] },
-  deserialization: { fn: ([reader]) => TxHash.fromField(reader.readField()), slots: 1 },
-};
-
-const TAG: TypeMapping<Tag> = {
-  serialization: { fn: v => [v.value] },
-  deserialization: { fn: ([reader]) => new Tag(reader.readField()), slots: 1 },
-};
-
-const BLOCK_HEADER: TypeMapping<BlockHeader> = {
-  serialization: { fn: v => v.toFields() },
-  deserialization: { fn: ([reader]) => BlockHeader.fromFields(reader.readFieldArray(BLOCK_HEADER_LENGTH)), slots: 1 },
-};
-
-const KEY_VALIDATION_REQUEST: TypeMapping<KeyValidationRequest> = {
-  serialization: { fn: v => v.toFields() },
-  deserialization: {
-    fn: ([reader]) => KeyValidationRequest.fromFields(reader.readFieldArray(KEY_VALIDATION_REQUEST_LENGTH)),
-    slots: 1,
-  },
-};
-
-const CONTRACT_INSTANCE: TypeMapping<ContractInstance> = {
-  serialization: {
-    fn: v => [
-      v.salt,
-      v.deployer.toField(),
-      v.currentContractClassId,
-      v.initializationHash,
-      v.immutablesHash,
-      ...v.publicKeys.toFields(),
-    ],
-  },
-};
-
-const NULLIFIER_MEMBERSHIP_WITNESS: TypeMapping<NullifierMembershipWitness> = {
-  serialization: {
-    fn: (w: NullifierMembershipWitness) =>
-      w
-        .toNoirRepresentation()
-        .map(slot => (Array.isArray(slot) ? slot.map(s => Fr.fromString(s)) : Fr.fromString(slot as string))),
-  },
-};
-
-const PUBLIC_DATA_WITNESS: TypeMapping<PublicDataWitness> = {
-  serialization: {
-    fn: (w: PublicDataWitness) =>
-      w
-        .toNoirRepresentation()
-        .map(slot => (Array.isArray(slot) ? slot.map(s => Fr.fromString(s)) : Fr.fromString(slot as string))),
-  },
-};
-
-const MESSAGE_LOAD_ORACLE_INPUTS: TypeMapping<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> = {
-  serialization: {
-    fn: (m: MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>) =>
-      m
-        .toNoirRepresentation()
-        .map(slot => (Array.isArray(slot) ? slot.map(s => Fr.fromString(s)) : Fr.fromString(slot as string))),
-  },
-};
-
-const UTILITY_CONTEXT: TypeMapping<UtilityContext> = {
-  serialization: {
-    fn: (ctx: UtilityContext) => [...ctx.blockHeader.toFields(), ctx.contractAddress.toField()],
-  },
-};
-
-const CALL_PRIVATE_RESULT: TypeMapping<{ endSideEffectCounter: Fr; returnsHash: Fr }> = {
-  serialization: { fn: v => [[v.endSideEffectCounter, v.returnsHash]] },
-};
-
-const PUBLIC_KEYS_AND_PARTIAL_ADDRESS: TypeMapping<{
-  publicKeys: PublicKeys;
-  partialAddress: PartialAddress;
-}> = {
-  serialization: {
-    fn: v => [[...v.publicKeys.toFields(), v.partialAddress]],
-  },
-};
-
-const CONTRACT_CLASS_LOG_INPUT: TypeMapping<ContractClassLog> = {
-  deserialization: {
-    fn: ([addrReader, fieldsReader, lengthReader]) => {
-      const addr = AztecAddress.fromField(addrReader.readField());
-      const fields = new ContractClassLogFields([...fieldsReader.readFieldArray(fieldsReader.remainingFields())]);
-      const length = lengthReader.readField().toNumber();
-      return new ContractClassLog(addr, fields, length);
-    },
-    // ContractClassLog input occupies 3 ACVM slots: [contractAddress], [message fields...], [length].
-    slots: 3,
-  },
-};
+import { toACVMField } from '@aztec/simulator/client';
+import type { UnsiloedMessageNullifier } from '@aztec/stdlib/messaging';
 
-const TX_EFFECT: TypeMapping<TxEffect> = {
-  serialization: {
-    fn: (effect: TxEffect) => {
-      const flatPublicLogs = FlatPublicLogs.fromLogs(effect.publicLogs);
-      return [
-        effect.revertCode.toField(),
-        effect.txHash.hash,
-        effect.transactionFee,
-        padArrayEnd(effect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-        padArrayEnd(effect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
-        padArrayEnd(effect.l2ToL1Msgs, Fr.ZERO, MAX_L2_TO_L1_MSGS_PER_TX),
-        padArrayEnd(
-          effect.publicDataWrites,
-          PublicDataWrite.empty(),
-          MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-        ).flatMap(w => w.toFields()),
-        padArrayEnd(effect.privateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX).flatMap(l => l.toFields()),
-        new Fr(flatPublicLogs.length),
-        flatPublicLogs.payload,
-        padArrayEnd(effect.contractClassLogs, ContractClassLog.empty(), MAX_CONTRACT_CLASS_LOGS_PER_TX).flatMap(l => [
-          ...l.fields.toFields(),
-          new Fr(l.emittedLength),
-          l.contractAddress.toField(),
-        ]),
-      ] as (Fr | Fr[])[];
-    },
-  },
-};
-
-const NOTE: TypeMapping<NoteData> = {
-  serialization: {
-    fn: noteData =>
-      packAsHintedNote({
-        contractAddress: noteData.contractAddress,
-        owner: noteData.owner,
-        randomness: noteData.randomness,
-        storageSlot: noteData.storageSlot,
-        noteNonce: noteData.noteNonce,
-        isPending: noteData.isPending,
-        note: noteData.note,
-      }),
-  },
-};
-
-const ORACLE_REGISTRY = {
-  aztec_utl_assertCompatibleOracleVersion: makeEntry({
+import {
+  ARRAY,
+  AZTEC_ADDRESS,
+  BLOCK_HASH,
+  BLOCK_HEADER,
+  BLOCK_NUMBER,
+  BOOL,
+  BOUNDED_VEC,
+  CALL_PRIVATE_RESULT,
+  CONTRACT_CLASS_LOG,
+  CONTRACT_INSTANCE,
+  DELIVERY_MODE,
+  EPHEMERAL_ARRAY,
+  EVENT_VALIDATION_REQUEST,
+  FACT_COLLECTION,
+  FIELD,
+  FIXED_ARRAY,
+  FUNCTION_SELECTOR,
+  type InputSlot,
+  KEY_VALIDATION_REQUEST,
+  LOG_RETRIEVAL_REQUEST,
+  LOG_RETRIEVAL_RESPONSE,
+  MEMBERSHIP_WITNESS,
+  MESSAGE_LOAD_ORACLE_INPUTS,
+  type MaybePromise,
+  NOTE,
+  NOTE_SELECTOR,
+  NOTE_VALIDATION_REQUEST,
+  NULLIFIER_MEMBERSHIP_WITNESS,
+  OPTION,
+  ORIGIN_BLOCK,
+  type OutputSlot,
+  PENDING_TAGGED_LOG,
+  POINT,
+  PROVIDED_SECRET,
+  PUBLIC_DATA_WITNESS,
+  PUBLIC_KEYS_AND_PARTIAL_ADDRESS,
+  RESOLVED_TAGGING_STRATEGY,
+  RESOLVED_TX,
+  STR,
+  STRUCT,
+  TX_EFFECT,
+  TX_HASH,
+  type TypeMapping,
+  U8,
+  U32,
+  UTILITY_CONTEXT,
+  assertReadersConsumed,
+  slotsOf,
+} from './oracle_type_mappings.js';
+
+export {
+  ARRAY,
+  AZTEC_ADDRESS,
+  BIGINT,
+  BLOCK_NUMBER,
+  BOOL,
+  BOUNDED_VEC,
+  U8,
+  CONTRACT_CLASS_LOG,
+  DELIVERY_MODE,
+  RESOLVED_TAGGING_STRATEGY,
+  EPHEMERAL_ARRAY,
+  EVENT_VALIDATION_REQUEST,
+  FIELD,
+  FUNCTION_SELECTOR,
+  LOG_RETRIEVAL_REQUEST,
+  LOG_RETRIEVAL_RESPONSE,
+  MEMBERSHIP_WITNESS,
+  NOTE_VALIDATION_REQUEST,
+  OPTION,
+  PENDING_TAGGED_LOG,
+  POINT,
+  PROVIDED_SECRET,
+  RESOLVED_TX,
+  STR,
+  U32,
+  slotsOf,
+  type InputSlot,
+  type MaybePromise,
+  type OutputSlot,
+  type SlotShape,
+  type TypeMapping,
+} from './oracle_type_mappings.js';
+
+export const ORACLE_REGISTRY = {
+  aztec_misc_assertCompatibleOracleVersion: makeEntry({
     params: [
       { name: 'major', type: U32 },
       { name: 'minor', type: U32 },
     ],
   }),
 
-  aztec_utl_getRandomField: makeEntry({ returnType: FIELD }),
+  aztec_misc_getRandomField: makeEntry({ returnType: FIELD }),
 
-  aztec_utl_log: makeEntry({
+  aztec_misc_log: makeEntry({
     params: [
       { name: 'level', type: U32 },
       { name: 'message', type: STR },
@@ -276,7 +112,10 @@ const ORACLE_REGISTRY = {
   aztec_utl_getUtilityContext: makeEntry({ returnType: UTILITY_CONTEXT }),
 
   aztec_utl_getKeyValidationRequest: makeEntry({
-    params: [{ name: 'pkMHash', type: FIELD }],
+    params: [
+      { name: 'pkMHash', type: FIELD },
+      { name: 'keyIndex', type: FIELD },
+    ],
     returnType: KEY_VALIDATION_REQUEST,
   }),
 
@@ -301,6 +140,14 @@ const ORACLE_REGISTRY = {
     returnType: OPTION(MEMBERSHIP_WITNESS(ARCHIVE_HEIGHT)),
   }),
 
+  aztec_utl_areBlockHashesInArchive: makeEntry({
+    params: [
+      { name: 'anchorBlockHash', type: BLOCK_HASH },
+      { name: 'blockHashes', type: EPHEMERAL_ARRAY(BLOCK_HASH) },
+    ],
+    returnType: EPHEMERAL_ARRAY(BOOL),
+  }),
+
   aztec_utl_getNullifierMembershipWitness: makeEntry({
     params: [
       { name: 'blockHash', type: BLOCK_HASH },
@@ -345,11 +192,18 @@ const ORACLE_REGISTRY = {
     returnType: BOOL,
   }),
 
-  aztec_utl_getL1ToL2MembershipWitness: makeEntry({
+  aztec_utl_getL1ToL2MembershipWitnessV2: makeEntry({
     params: [
-      { name: 'contractAddress', type: AZTEC_ADDRESS },
       { name: 'messageHash', type: FIELD },
-      { name: 'secret', type: FIELD },
+      {
+        name: 'nullifier',
+        type: OPTION(
+          STRUCT<UnsiloedMessageNullifier>([
+            { name: 'contractAddress', type: AZTEC_ADDRESS },
+            { name: 'nullifier', type: FIELD },
+          ]),
+        ),
+      },
     ],
     returnType: MESSAGE_LOAD_ORACLE_INPUTS,
   }),
@@ -387,27 +241,30 @@ const ORACLE_REGISTRY = {
     returnType: BOUNDED_VEC(NOTE),
   }),
 
-  aztec_utl_getPendingTaggedLogs: makeEntry({
-    params: [{ name: 'scope', type: AZTEC_ADDRESS }],
-    returnType: FIELD,
+  aztec_utl_getPendingTaggedLogsV2: makeEntry({
+    params: [
+      { name: 'scope', type: AZTEC_ADDRESS },
+      { name: 'providedSecrets', type: EPHEMERAL_ARRAY(PROVIDED_SECRET) },
+    ],
+    returnType: EPHEMERAL_ARRAY(PENDING_TAGGED_LOG),
   }),
 
   aztec_utl_validateAndStoreEnqueuedNotesAndEvents: makeEntry({
     params: [
-      { name: 'noteValidationRequestsArrayBaseSlot', type: FIELD },
-      { name: 'eventValidationRequestsArrayBaseSlot', type: FIELD },
+      { name: 'noteValidationRequests', type: EPHEMERAL_ARRAY(NOTE_VALIDATION_REQUEST) },
+      { name: 'eventValidationRequests', type: EPHEMERAL_ARRAY(EVENT_VALIDATION_REQUEST) },
       { name: 'scope', type: AZTEC_ADDRESS },
     ],
   }),
 
-  aztec_utl_getLogsByTag: makeEntry({
-    params: [{ name: 'requestArrayBaseSlot', type: FIELD }],
-    returnType: FIELD,
+  aztec_utl_getLogsByTagV2: makeEntry({
+    params: [{ name: 'requests', type: EPHEMERAL_ARRAY(LOG_RETRIEVAL_REQUEST) }],
+    returnType: EPHEMERAL_ARRAY(EPHEMERAL_ARRAY(LOG_RETRIEVAL_RESPONSE)),
   }),
 
-  aztec_utl_getMessageContextsByTxHash: makeEntry({
-    params: [{ name: 'requestArrayBaseSlot', type: FIELD }],
-    returnType: FIELD,
+  aztec_utl_getResolvedTxs: makeEntry({
+    params: [{ name: 'requests', type: EPHEMERAL_ARRAY(FIELD) }],
+    returnType: EPHEMERAL_ARRAY(OPTION(RESOLVED_TX)),
   }),
 
   aztec_utl_getTxEffect: makeEntry({
@@ -415,6 +272,11 @@ const ORACLE_REGISTRY = {
     returnType: OPTION(TX_EFFECT),
   }),
 
+  aztec_utl_getTxEffects: makeEntry({
+    params: [{ name: 'txHashes', type: EPHEMERAL_ARRAY(TX_HASH) }],
+    returnType: EPHEMERAL_ARRAY(OPTION(TX_EFFECT)),
+  }),
+
   aztec_utl_setCapsule: makeEntry({
     params: [
       { name: 'contractAddress', type: AZTEC_ADDRESS },
@@ -454,20 +316,20 @@ const ORACLE_REGISTRY = {
 
   aztec_utl_decryptAes128: makeEntry({
     params: [
-      { name: 'ciphertext', type: BOUNDED_VEC(BYTE) },
-      { name: 'iv', type: BUFFER(8) },
-      { name: 'symKey', type: BUFFER(8) },
+      { name: 'ciphertext', type: BOUNDED_VEC(U8) },
+      { name: 'iv', type: FIXED_ARRAY(U8, 16) },
+      { name: 'symKey', type: FIXED_ARRAY(U8, 16) },
     ],
-    returnType: OPTION(BOUNDED_VEC(BYTE)),
+    returnType: OPTION(BOUNDED_VEC(U8)),
   }),
 
   aztec_utl_getSharedSecrets: makeEntry({
     params: [
       { name: 'address', type: AZTEC_ADDRESS },
-      { name: 'ephPksSlot', type: FIELD },
+      { name: 'ephPks', type: EPHEMERAL_ARRAY(POINT) },
       { name: 'contractAddress', type: AZTEC_ADDRESS },
     ],
-    returnType: FIELD,
+    returnType: EPHEMERAL_ARRAY(FIELD),
   }),
 
   aztec_utl_setContractSyncCacheInvalid: makeEntry({
@@ -481,6 +343,46 @@ const ORACLE_REGISTRY = {
     params: [{ name: 'data', type: ARRAY(FIELD) }],
   }),
 
+  aztec_utl_recordFact: makeEntry({
+    params: [
+      { name: 'contractAddress', type: AZTEC_ADDRESS },
+      { name: 'scope', type: AZTEC_ADDRESS },
+      { name: 'factCollectionTypeId', type: FIELD },
+      { name: 'factCollectionId', type: FIELD },
+      { name: 'factTypeId', type: FIELD },
+      { name: 'payload', type: EPHEMERAL_ARRAY(FIELD) },
+      { name: 'originBlock', type: OPTION(ORIGIN_BLOCK) },
+    ],
+  }),
+
+  aztec_utl_deleteFactCollection: makeEntry({
+    params: [
+      { name: 'contractAddress', type: AZTEC_ADDRESS },
+      { name: 'scope', type: AZTEC_ADDRESS },
+      { name: 'factCollectionTypeId', type: FIELD },
+      { name: 'factCollectionId', type: FIELD },
+    ],
+  }),
+
+  aztec_utl_getFactCollection: makeEntry({
+    params: [
+      { name: 'contractAddress', type: AZTEC_ADDRESS },
+      { name: 'scope', type: AZTEC_ADDRESS },
+      { name: 'factCollectionTypeId', type: FIELD },
+      { name: 'factCollectionId', type: FIELD },
+    ],
+    returnType: OPTION(FACT_COLLECTION),
+  }),
+
+  aztec_utl_getFactCollectionsByType: makeEntry({
+    params: [
+      { name: 'contractAddress', type: AZTEC_ADDRESS },
+      { name: 'scope', type: AZTEC_ADDRESS },
+      { name: 'factCollectionTypeId', type: FIELD },
+    ],
+    returnType: EPHEMERAL_ARRAY(FACT_COLLECTION),
+  }),
+
   aztec_utl_callUtilityFunction: makeEntry({
     params: [
       { name: 'contractAddress', type: AZTEC_ADDRESS },
@@ -535,6 +437,51 @@ const ORACLE_REGISTRY = {
     params: [{ name: 'slot', type: FIELD }],
   }),
 
+  aztec_utl_pushTransient: makeEntry({
+    params: [
+      { name: 'slot', type: FIELD },
+      { name: 'elements', type: ARRAY(FIELD) },
+    ],
+    returnType: U32,
+  }),
+
+  aztec_utl_popTransient: makeEntry({
+    params: [{ name: 'slot', type: FIELD }],
+    returnType: ARRAY(FIELD),
+  }),
+
+  aztec_utl_getTransient: makeEntry({
+    params: [
+      { name: 'slot', type: FIELD },
+      { name: 'index', type: U32 },
+    ],
+    returnType: ARRAY(FIELD),
+  }),
+
+  aztec_utl_setTransient: makeEntry({
+    params: [
+      { name: 'slot', type: FIELD },
+      { name: 'index', type: U32 },
+      { name: 'elements', type: ARRAY(FIELD) },
+    ],
+  }),
+
+  aztec_utl_getTransientLen: makeEntry({
+    params: [{ name: 'slot', type: FIELD }],
+    returnType: U32,
+  }),
+
+  aztec_utl_removeTransient: makeEntry({
+    params: [
+      { name: 'slot', type: FIELD },
+      { name: 'index', type: U32 },
+    ],
+  }),
+
+  aztec_utl_clearTransient: makeEntry({
+    params: [{ name: 'slot', type: FIELD }],
+  }),
+
   aztec_prv_setHashPreimage: makeEntry({
     params: [
       { name: 'values', type: ARRAY(FIELD) },
@@ -581,7 +528,7 @@ const ORACLE_REGISTRY = {
 
   aztec_prv_notifyCreatedContractClassLog: makeEntry({
     params: [
-      { name: 'log', type: CONTRACT_CLASS_LOG_INPUT },
+      { name: 'log', type: CONTRACT_CLASS_LOG },
       { name: 'counter', type: U32 },
     ],
   }),
@@ -610,74 +557,43 @@ const ORACLE_REGISTRY = {
     returnType: BOOL,
   }),
 
-  aztec_prv_getNextAppTagAsSender: makeEntry({
+  aztec_prv_getAppTaggingSecret: makeEntry({
     params: [
       { name: 'sender', type: AZTEC_ADDRESS },
       { name: 'recipient', type: AZTEC_ADDRESS },
     ],
-    returnType: TAG,
+    returnType: OPTION(FIELD),
   }),
 
-  aztec_prv_getNextConstrainedTaggingIndex: makeEntry({
-    params: [{ name: 'appSiloedSecret', type: FIELD }],
+  aztec_prv_getNextTaggingIndex: makeEntry({
+    params: [
+      { name: 'secret', type: FIELD },
+      { name: 'deliveryMode', type: DELIVERY_MODE },
+    ],
     returnType: U32,
   }),
 
   aztec_prv_getSenderForTags: makeEntry({ returnType: OPTION(AZTEC_ADDRESS) }),
-} satisfies Record<string, OracleRegistryEntry>;
 
-/**
- * Deserializes oracle inputs, calls the handler with typed params, and serializes the result.
- */
-export async function callHandler<K extends keyof typeof ORACLE_REGISTRY>({
-  oracle,
-  inputs,
-  handler,
-}: {
-  oracle: K;
-  inputs: InputSlot[];
-  handler: (
-    params: ParamTypes<ReturnType<(typeof ORACLE_REGISTRY)[K]['deserializeParams']>>,
-  ) => MaybePromise<Parameters<(typeof ORACLE_REGISTRY)[K]['serializeReturn']>[0]>;
-}): Promise<OutputSlot[]> {
-  const entry = ORACLE_REGISTRY[oracle] as OracleRegistryEntry;
-  const named = entry.deserializeParams(inputs);
-  const positional = named.map(p => p.value);
-  const result = await handler(positional as any);
-  return entry.serializeReturn(result);
-}
-
-// ─── Helper Types ─────────────────────────────────────────────────────────────
-
-/** One ACVM input slot: an array of hex-encoded field strings. */
-type InputSlot = ACVMField[];
+  aztec_prv_resolveTaggingStrategy: makeEntry({
+    params: [
+      { name: 'sender', type: AZTEC_ADDRESS },
+      { name: 'recipient', type: AZTEC_ADDRESS },
+      { name: 'deliveryMode', type: DELIVERY_MODE },
+    ],
+    returnType: RESOLVED_TAGGING_STRATEGY,
+  }),
 
-/** One ACVM output slot: a scalar hex string or an array of hex strings. */
-type OutputSlot = ACVMField | ACVMField[];
+  aztec_prv_resolveCustomRequest: makeEntry({
+    params: [
+      { name: 'kind', type: FIELD },
+      { name: 'payload', type: ARRAY(FIELD) },
+    ],
+    returnType: ARRAY(FIELD),
+  }),
+} satisfies Record<string, OracleRegistryEntry>;
 
-/**
- * Describes how to serialize and/or deserialize a single typed value to/from ACVM wire format.
- * Either side is optional — output-only types omit `deserialization`, input-only types omit `serialization`.
- */
-export interface TypeMapping<T = any> {
-  serialization?: {
-    /** Convert a typed value to ACVM output slot(s). */
-    fn: (value: T) => (Fr | Fr[])[];
-  };
-  deserialization?: {
-    /** Read a typed value from one FieldReader per consumed slot. */
-    fn: (readers: FieldReader[]) => T;
-    /**
-     * Number of InputSlots this type reads from. `deserialization.fn` receives one FieldReader per slot in `readers`.
-     *
-     * Examples:
-     * - `FIELD`, `U32`, `AZTEC_ADDRESS` — single slot         → `slots: 1`
-     * - `OPTION(T)` — discriminant + inner slots              → `slots: T.slots + 1`
-     * - `CONTRACT_CLASS_LOG_INPUT` — [addr], [fields], [len]  → `slots: 3`
-     */
-    slots: number;
-  };
-}
+// ─── Registry Infrastructure ─────────────────────────────────────────────────
 
 /**
  * A full oracle registry entry describing param and return serialization.
@@ -685,7 +601,7 @@ export interface TypeMapping<T = any> {
  * TDeserializedParams — the array of named pairs returned by `deserializeParams`.
  * TReturnValue — the typed handler return value consumed by `serializeReturn`.
  */
-interface OracleRegistryEntry<
+export interface OracleRegistryEntry<
   TDeserializedParams extends readonly NamedValue[] = readonly NamedValue[],
   TReturnValue = any,
 > {
@@ -693,9 +609,13 @@ interface OracleRegistryEntry<
   deserializeParams(inputs: InputSlot[]): TDeserializedParams;
   /** Serialize a handler return value into ACVM output slots. */
   serializeReturn(result: TReturnValue): OutputSlot[];
+  /** The ordered named parameters with their {@link TypeMapping}s. Lets callers introspect the oracle's wire ABI. */
+  readonly params: readonly RegistryParam[];
+  /** The return {@link TypeMapping}, or `undefined` for oracles that return nothing. */
+  readonly returnType?: TypeMapping<TReturnValue>;
 }
 
-function makeEntry<const TParams extends RegistryParam[] = [], TReturnValue = void>({
+export function makeEntry<const TParams extends RegistryParam[] = [], TReturnValue = void>({
   params,
   returnType,
 }: {
@@ -703,23 +623,34 @@ function makeEntry<const TParams extends RegistryParam[] = [], TReturnValue = vo
   returnType?: TypeMapping<TReturnValue>;
 } = {}): OracleRegistryEntry<InferDeserializedParams<TParams>, TReturnValue> {
   return {
+    params: params ?? [],
+    returnType,
     deserializeParams(inputs: InputSlot[]): InferDeserializedParams<TParams> {
       const resolvedParams: RegistryParam[] = params ?? [];
       // Walk the input slots left-to-right, advancing by each param's slot count.
       let offset = 0;
-      return resolvedParams.map(param => {
+      const named = resolvedParams.map(param => {
         if (!param.type.deserialization) {
           throw new Error(`Param '${param.name}' has no deserialization defined`);
         }
         // Collect the slots for this param and wrap each in a FieldReader.
-        const slotCount = param.type.deserialization.slots;
+        const slotCount = slotsOf(param.type);
         const readers = inputs
           .slice(offset, offset + slotCount)
           .map(slot => new FieldReader(slot.map(hex => Fr.fromString(hex))));
         offset += slotCount;
-        // Delegate to the TypeMapping's deserializer and tag the result with the param name.
-        return { name: param.name, value: param.type.deserialization.fn(readers) };
-      }) as unknown as InferDeserializedParams<TParams>;
+        // Delegate to the TypeMapping's deserializer, assert the param's slots are fully consumed, and tag the
+        // result with the param name.
+        const value = param.type.deserialization.fn(readers);
+        assertReadersConsumed(readers);
+        return { name: param.name, value };
+      });
+      // Every input slot must be specified by a param: oracles whose Noir decl passes an extra field must declare it
+      // (the handler can ignore it). Otherwise an under-declared shape would silently drop a field into nothing.
+      if (offset !== inputs.length) {
+        throw new Error(`Oracle received ${inputs.length} input slot(s) but the registry specifies ${offset}`);
+      }
+      return named as unknown as InferDeserializedParams<TParams>;
     },
     serializeReturn(result: TReturnValue): OutputSlot[] {
       if (returnType?.serialization === undefined) {
@@ -732,152 +663,14 @@ function makeEntry<const TParams extends RegistryParam[] = [], TReturnValue = vo
   };
 }
 
-/** `_height` is unused at runtime but lets TypeScript infer the exact `N` for `MembershipWitness<N>`. */
-function MEMBERSHIP_WITNESS<N extends number>(_height: N): TypeMapping<MembershipWitness<N>> {
-  return {
-    serialization: {
-      fn: (witness: MembershipWitness<N>) => [new Fr(witness.leafIndex), [...witness.siblingPath]],
-    },
-  };
-}
-
-function ARRAY<T>(element: TypeMapping<T>): TypeMapping<T[]> {
-  return {
-    serialization: element.serialization
-      ? { fn: values => [values.flatMap(v => element.serialization!.fn(v).flat())] }
-      : undefined,
-    deserialization: element.deserialization
-      ? {
-          fn: ([reader]) => {
-            const result: T[] = [];
-            while (!reader.isFinished()) {
-              result.push(element.deserialization!.fn([reader]));
-            }
-            return result;
-          },
-          slots: 1,
-        }
-      : undefined,
-  };
-}
-
-/**
- * Maps Noir's `BoundedVec<T, MaxLen>` ↔ TS `BoundedVec<T>` over 2 slots:
- *   slot 0 — flat storage, padded/parsed as `maxLength * elementSize` fields
- *   slot 1 — length scalar (count of actual items)
- *
- * Both directions are derived from `element`: bidirectional iff `element` has both serialization and deserialization.
- *
- * @example Serializing `BoundedVec.from({ data: [0x41, 0x42], maxLength: 4 })` with `BOUNDED_VEC(BYTE)`:
- * ```
- * slot 0: [Fr(0x41), Fr(0x42), Fr(0), Fr(0)]     // data padded to maxLength
- * slot 1: Fr(2)                                  // actual length
- * ```
- */
-function BOUNDED_VEC<T>(element: TypeMapping<T>): TypeMapping<BoundedVec<T>> {
-  return {
-    serialization: element.serialization
-      ? {
-          fn: bv => {
-            if (bv.data.length > bv.maxLength) {
-              throw new Error(`Got ${bv.data.length} items, but maxLength is ${bv.maxLength}`);
-            }
-            const flat = bv.data.flatMap(item => element.serialization!.fn(item).flat());
-            return [padArrayEnd(flat, Fr.ZERO, bv.maxLength * bv.elementSize), new Fr(bv.data.length)];
-          },
-        }
-      : undefined,
-    deserialization: element.deserialization
-      ? {
-          fn: ([storageReader, lengthReader]) => {
-            const maxLength = storageReader.remainingFields();
-            const length = lengthReader.readField().toNumber();
-            const elements: T[] = [];
-            for (let i = 0; i < length; i++) {
-              elements.push(element.deserialization!.fn([storageReader]));
-            }
-            return BoundedVec.from<T>({ data: elements, maxLength });
-          },
-          slots: 2,
-        }
-      : undefined,
-  };
-}
-
-/**
- * Wraps an inner TypeMapping in Noir-style `Option<T>`. Adds a discriminant slot and uses the handler-provided
- * `Option.none(shape)` template to produce a correctly-sized zero-filled output for the None case.
- *
- * @example Serializing `Option.some(AztecAddress.fromField(Fr(42)))` with `OPTION(AZTEC_ADDRESS)`:
- * ```
- * slot 0: Fr(1)    // discriminant: Some
- * slot 1: Fr(42)   // inner value
- * ```
- *
- * @example Serializing `Option.empty(AztecAddress.ZERO)` with `OPTION(AZTEC_ADDRESS)`:
- * ```
- * slot 0: Fr(0)    // discriminant: None
- * slot 1: Fr(0)    // zero-filled using shape
- * ```
- */
-function OPTION<T>(inner: TypeMapping<T>): TypeMapping<Option<T>> {
-  return {
-    serialization: inner.serialization
-      ? {
-          fn: opt => {
-            if (opt.isSome()) {
-              return [Fr.ONE, ...inner.serialization!.fn(opt.value)];
-            }
-            if (opt.template === undefined) {
-              throw new Error(
-                'Cannot serialize Option.empty() without an emptyTemplate — provide one via Option.empty(emptyTemplate)',
-              );
-            }
-            const zeroSlots = inner
-              .serialization!.fn(opt.template)
-              .map(s => (Array.isArray(s) ? Array(s.length).fill(Fr.ZERO) : Fr.ZERO));
-            return [Fr.ZERO, ...zeroSlots];
-          },
-        }
-      : undefined,
-    deserialization: inner.deserialization
-      ? {
-          fn: readers => {
-            if (readers[0].readField().isZero()) {
-              return Option.none<T>(undefined as unknown as T);
-            }
-            return Option.some(inner.deserialization!.fn(readers.slice(1)));
-          },
-          slots: inner.deserialization.slots + 1,
-        }
-      : undefined,
-  };
-}
-
-/** A packed uint buffer (e.g. `[u8; N]` in Noir): 1 slot of packed uint values ↔ `Buffer`. */
-function BUFFER(bitSize: number): TypeMapping<Buffer> {
-  return {
-    serialization: {
-      fn: buf => [Array.from(buf).map(b => new Fr(b))],
-    },
-    deserialization: {
-      fn: ([reader]) => {
-        const fields = reader.readFieldArray(reader.remainingFields()).map(f => f.toString());
-        return fromUintArray(fields, bitSize);
-      },
-      slots: 1,
-    },
-  };
-}
-
 /** A named oracle parameter with its TypeMapping. */
-interface RegistryParam<TName extends string = string, T = any> {
+export interface RegistryParam<TName extends string = string, T = any> {
   name: TName;
   type: TypeMapping<T>;
 }
 
 /** One named param entry from a deserializeParams result. */
-type NamedValue<TName extends string = string, TValue = any> = { readonly name: TName; readonly value: TValue };
+export type NamedValue<TName extends string = string, TValue = any> = { readonly name: TName; readonly value: TValue };
 
 /**
  * Extracts the positional type tuple from a {@link OracleRegistryEntry.deserializeParams} result,
@@ -885,7 +678,7 @@ type NamedValue<TName extends string = string, TValue = any> = { readonly name:
  *
  * @example `ParamTypes<[NamedValue<'addr', AztecAddress>, NamedValue<'slot', Fr>]>` → `[AztecAddress, Fr]`
  */
-type ParamTypes<T extends readonly NamedValue[]> = {
+export type ParamTypes<T extends readonly NamedValue[]> = {
   [K in keyof T]: T[K] extends NamedValue<string, infer V> ? V : never;
 };
 
@@ -897,8 +690,21 @@ type ParamTypes<T extends readonly NamedValue[]> = {
  * @example `InferDeserializedParams<[RegistryParam<'addr', AztecAddress>, RegistryParam<'slot', Fr>]>`
  *        → `[NamedValue<'addr', AztecAddress>, NamedValue<'slot', Fr>]`
  */
-type InferDeserializedParams<T extends RegistryParam[]> = {
+export type InferDeserializedParams<T extends RegistryParam[]> = {
   [K in keyof T]: T[K] extends RegistryParam<infer N, infer V> ? NamedValue<N, V> : never;
 };
 
-type MaybePromise<T> = T | Promise<T>;
+// ─── Derived Handler Interfaces ─────────────────────────────────────────────
+
+/** Strips the `aztec_{scope}_` prefix from an oracle key to get the handler method name. */
+type StripOraclePrefix<K extends string> = K extends `aztec_${string}_${infer M}` ? M : never;
+
+/** Derives the handler function signature from a registry entry's deserialization/serialization types. */
+type HandlerFn<E extends OracleRegistryEntry> = (
+  ...args: ParamTypes<ReturnType<E['deserializeParams']>>
+) => MaybePromise<Parameters<E['serializeReturn']>[0]>;
+
+/** Collects all oracle handler methods for a given name prefix into a single object type. */
+export type HandlersForPrefix<R extends Record<string, OracleRegistryEntry>, P extends string> = {
+  [K in keyof R as K extends `aztec_${P}_${string}` ? StripOraclePrefix<K & string> : never]: HandlerFn<R[K]>;
+};