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

package/dest/contract_function_simulator/oracle/oracle_registry.js

@@ -1,295 +1,11 @@
-/* eslint-disable camelcase */ import { ARCHIVE_HEIGHT, BLOCK_HEADER_LENGTH, KEY_VALIDATION_REQUEST_LENGTH, 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';
+/* eslint-disable camelcase */ import { ARCHIVE_HEIGHT, NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
-import { 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 { KeyValidationRequest } from '@aztec/stdlib/kernel';
-import { ContractClassLog, ContractClassLogFields, FlatPublicLogs, PrivateLog, Tag } from '@aztec/stdlib/logs';
-import { BlockHeader, TxHash } from '@aztec/stdlib/tx';
-import { BoundedVec } from '../noir-structs/bounded_vec.js';
-import { Option } from '../noir-structs/option.js';
-import { packAsHintedNote } from './note_packing_utils.js';
-const FIELD = {
-    serialization: {
-        fn: (v)=>[
-                v
-            ]
-    },
-    deserialization: {
-        fn: ([reader])=>reader.readField(),
-        slots: 1
-    }
-};
-const BOOL = {
-    serialization: {
-        fn: (v)=>[
-                new Fr(v ? 1n : 0n)
-            ]
-    },
-    deserialization: {
-        fn: ([reader])=>!reader.readField().isZero(),
-        slots: 1
-    }
-};
-export const U32 = {
-    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 = {
-    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 = {
-    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 = {
-    serialization: {
-        fn: (str)=>[
-                Array.from(Buffer.from(str, 'utf-8')).map((b)=>new Fr(b))
-            ]
-    },
-    deserialization: {
-        fn: ([reader])=>{
-            const chars = [];
-            while(!reader.isFinished()){
-                chars.push(String.fromCharCode(reader.readField().toNumber()));
-            }
-            return chars.join('');
-        },
-        slots: 1
-    }
-};
-const AZTEC_ADDRESS = {
-    serialization: {
-        fn: (v)=>[
-                v.toField()
-            ]
-    },
-    deserialization: {
-        fn: ([reader])=>AztecAddress.fromField(reader.readField()),
-        slots: 1
-    }
-};
-const BLOCK_HASH = {
-    serialization: {
-        fn: (v)=>[
-                new Fr(v.toBuffer())
-            ]
-    },
-    deserialization: {
-        fn: ([reader])=>new BlockHash(reader.readField()),
-        slots: 1
-    }
-};
-const FUNCTION_SELECTOR = {
-    serialization: {
-        fn: (v)=>[
-                v.toField()
-            ]
-    },
-    deserialization: {
-        fn: ([reader])=>FunctionSelector.fromField(reader.readField()),
-        slots: 1
-    }
-};
-const NOTE_SELECTOR = {
-    serialization: {
-        fn: (v)=>[
-                v.toField()
-            ]
-    },
-    deserialization: {
-        fn: ([reader])=>NoteSelector.fromField(reader.readField()),
-        slots: 1
-    }
-};
-const TX_HASH = {
-    serialization: {
-        fn: (v)=>[
-                v.hash
-            ]
-    },
-    deserialization: {
-        fn: ([reader])=>TxHash.fromField(reader.readField()),
-        slots: 1
-    }
-};
-const TAG = {
-    serialization: {
-        fn: (v)=>[
-                v.value
-            ]
-    },
-    deserialization: {
-        fn: ([reader])=>new Tag(reader.readField()),
-        slots: 1
-    }
-};
-const BLOCK_HEADER = {
-    serialization: {
-        fn: (v)=>v.toFields()
-    },
-    deserialization: {
-        fn: ([reader])=>BlockHeader.fromFields(reader.readFieldArray(BLOCK_HEADER_LENGTH)),
-        slots: 1
-    }
-};
-const KEY_VALIDATION_REQUEST = {
-    serialization: {
-        fn: (v)=>v.toFields()
-    },
-    deserialization: {
-        fn: ([reader])=>KeyValidationRequest.fromFields(reader.readFieldArray(KEY_VALIDATION_REQUEST_LENGTH)),
-        slots: 1
-    }
-};
-const CONTRACT_INSTANCE = {
-    serialization: {
-        fn: (v)=>[
-                v.salt,
-                v.deployer.toField(),
-                v.currentContractClassId,
-                v.initializationHash,
-                v.immutablesHash,
-                ...v.publicKeys.toFields()
-            ]
-    }
-};
-const NULLIFIER_MEMBERSHIP_WITNESS = {
-    serialization: {
-        fn: (w)=>w.toNoirRepresentation().map((slot)=>Array.isArray(slot) ? slot.map((s)=>Fr.fromString(s)) : Fr.fromString(slot))
-    }
-};
-const PUBLIC_DATA_WITNESS = {
-    serialization: {
-        fn: (w)=>w.toNoirRepresentation().map((slot)=>Array.isArray(slot) ? slot.map((s)=>Fr.fromString(s)) : Fr.fromString(slot))
-    }
-};
-const MESSAGE_LOAD_ORACLE_INPUTS = {
-    serialization: {
-        fn: (m)=>m.toNoirRepresentation().map((slot)=>Array.isArray(slot) ? slot.map((s)=>Fr.fromString(s)) : Fr.fromString(slot))
-    }
-};
-const UTILITY_CONTEXT = {
-    serialization: {
-        fn: (ctx)=>[
-                ...ctx.blockHeader.toFields(),
-                ctx.contractAddress.toField()
-            ]
-    }
-};
-const CALL_PRIVATE_RESULT = {
-    serialization: {
-        fn: (v)=>[
-                [
-                    v.endSideEffectCounter,
-                    v.returnsHash
-                ]
-            ]
-    }
-};
-const PUBLIC_KEYS_AND_PARTIAL_ADDRESS = {
-    serialization: {
-        fn: (v)=>[
-                [
-                    ...v.publicKeys.toFields(),
-                    v.partialAddress
-                ]
-            ]
-    }
-};
-const CONTRACT_CLASS_LOG_INPUT = {
-    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
-    }
-};
-const TX_EFFECT = {
-    serialization: {
-        fn: (effect)=>{
-            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()
-                    ])
-            ];
-        }
-    }
-};
-const NOTE = {
-    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 { toACVMField } from '@aztec/simulator/client';
+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, KEY_VALIDATION_REQUEST, LOG_RETRIEVAL_REQUEST, LOG_RETRIEVAL_RESPONSE, MEMBERSHIP_WITNESS, MESSAGE_LOAD_ORACLE_INPUTS, NOTE, NOTE_SELECTOR, NOTE_VALIDATION_REQUEST, NULLIFIER_MEMBERSHIP_WITNESS, OPTION, ORIGIN_BLOCK, 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, 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 } from './oracle_type_mappings.js';
+export const ORACLE_REGISTRY = {
+    aztec_misc_assertCompatibleOracleVersion: makeEntry({
         params: [
             {
                 name: 'major',
@@ -301,10 +17,10 @@ const ORACLE_REGISTRY = {
             }
         ]
     }),
-    aztec_utl_getRandomField: makeEntry({
+    aztec_misc_getRandomField: makeEntry({
         returnType: FIELD
     }),
-    aztec_utl_log: makeEntry({
+    aztec_misc_log: makeEntry({
         params: [
             {
                 name: 'level',
@@ -332,6 +48,10 @@ const ORACLE_REGISTRY = {
             {
                 name: 'pkMHash',
                 type: FIELD
+            },
+            {
+                name: 'keyIndex',
+                type: FIELD
             }
         ],
         returnType: KEY_VALIDATION_REQUEST
@@ -371,6 +91,19 @@ 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: [
             {
@@ -446,19 +179,24 @@ 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([
+                    {
+                        name: 'contractAddress',
+                        type: AZTEC_ADDRESS
+                    },
+                    {
+                        name: 'nullifier',
+                        type: FIELD
+                    }
+                ]))
             }
         ],
         returnType: MESSAGE_LOAD_ORACLE_INPUTS
@@ -557,24 +295,28 @@ const ORACLE_REGISTRY = {
         ],
         returnType: BOUNDED_VEC(NOTE)
     }),
-    aztec_utl_getPendingTaggedLogs: makeEntry({
+    aztec_utl_getPendingTaggedLogsV2: makeEntry({
         params: [
             {
                 name: 'scope',
                 type: AZTEC_ADDRESS
+            },
+            {
+                name: 'providedSecrets',
+                type: EPHEMERAL_ARRAY(PROVIDED_SECRET)
             }
         ],
-        returnType: FIELD
+        returnType: EPHEMERAL_ARRAY(PENDING_TAGGED_LOG)
     }),
     aztec_utl_validateAndStoreEnqueuedNotesAndEvents: makeEntry({
         params: [
             {
-                name: 'noteValidationRequestsArrayBaseSlot',
-                type: FIELD
+                name: 'noteValidationRequests',
+                type: EPHEMERAL_ARRAY(NOTE_VALIDATION_REQUEST)
             },
             {
-                name: 'eventValidationRequestsArrayBaseSlot',
-                type: FIELD
+                name: 'eventValidationRequests',
+                type: EPHEMERAL_ARRAY(EVENT_VALIDATION_REQUEST)
             },
             {
                 name: 'scope',
@@ -582,23 +324,23 @@ const ORACLE_REGISTRY = {
             }
         ]
     }),
-    aztec_utl_getLogsByTag: makeEntry({
+    aztec_utl_getLogsByTagV2: makeEntry({
         params: [
             {
-                name: 'requestArrayBaseSlot',
-                type: FIELD
+                name: 'requests',
+                type: EPHEMERAL_ARRAY(LOG_RETRIEVAL_REQUEST)
             }
         ],
-        returnType: FIELD
+        returnType: EPHEMERAL_ARRAY(EPHEMERAL_ARRAY(LOG_RETRIEVAL_RESPONSE))
     }),
-    aztec_utl_getMessageContextsByTxHash: makeEntry({
+    aztec_utl_getResolvedTxs: makeEntry({
         params: [
             {
-                name: 'requestArrayBaseSlot',
-                type: FIELD
+                name: 'requests',
+                type: EPHEMERAL_ARRAY(FIELD)
             }
         ],
-        returnType: FIELD
+        returnType: EPHEMERAL_ARRAY(OPTION(RESOLVED_TX))
     }),
     aztec_utl_getTxEffect: makeEntry({
         params: [
@@ -609,6 +351,15 @@ 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: [
             {
@@ -694,18 +445,18 @@ const ORACLE_REGISTRY = {
         params: [
             {
                 name: 'ciphertext',
-                type: BOUNDED_VEC(BYTE)
+                type: BOUNDED_VEC(U8)
             },
             {
                 name: 'iv',
-                type: BUFFER(8)
+                type: FIXED_ARRAY(U8, 16)
             },
             {
                 name: 'symKey',
-                type: BUFFER(8)
+                type: FIXED_ARRAY(U8, 16)
             }
         ],
-        returnType: OPTION(BOUNDED_VEC(BYTE))
+        returnType: OPTION(BOUNDED_VEC(U8))
     }),
     aztec_utl_getSharedSecrets: makeEntry({
         params: [
@@ -714,15 +465,15 @@ const ORACLE_REGISTRY = {
                 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({
         params: [
@@ -744,6 +495,96 @@ const ORACLE_REGISTRY = {
             }
         ]
     }),
+    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: [
             {
@@ -841,6 +682,86 @@ const ORACLE_REGISTRY = {
             }
         ]
     }),
+    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: [
             {
@@ -935,7 +856,7 @@ const ORACLE_REGISTRY = {
         params: [
             {
                 name: 'log',
-                type: CONTRACT_CLASS_LOG_INPUT
+                type: CONTRACT_CLASS_LOG
             },
             {
                 name: 'counter',
@@ -993,7 +914,7 @@ const ORACLE_REGISTRY = {
         ],
         returnType: BOOL
     }),
-    aztec_prv_getNextAppTagAsSender: makeEntry({
+    aztec_prv_getAppTaggingSecret: makeEntry({
         params: [
             {
                 name: 'sender',
@@ -1004,50 +925,86 @@ const ORACLE_REGISTRY = {
                 type: AZTEC_ADDRESS
             }
         ],
-        returnType: TAG
+        returnType: OPTION(FIELD)
     }),
-    aztec_prv_getNextConstrainedTaggingIndex: makeEntry({
+    aztec_prv_getNextTaggingIndex: makeEntry({
         params: [
             {
-                name: 'appSiloedSecret',
+                name: 'secret',
                 type: FIELD
+            },
+            {
+                name: 'deliveryMode',
+                type: DELIVERY_MODE
             }
         ],
         returnType: U32
     }),
     aztec_prv_getSenderForTags: makeEntry({
         returnType: OPTION(AZTEC_ADDRESS)
+    }),
+    aztec_prv_resolveTaggingStrategy: makeEntry({
+        params: [
+            {
+                name: 'sender',
+                type: AZTEC_ADDRESS
+            },
+            {
+                name: 'recipient',
+                type: AZTEC_ADDRESS
+            },
+            {
+                name: 'deliveryMode',
+                type: DELIVERY_MODE
+            }
+        ],
+        returnType: RESOLVED_TAGGING_STRATEGY
+    }),
+    aztec_prv_resolveCustomRequest: makeEntry({
+        params: [
+            {
+                name: 'kind',
+                type: FIELD
+            },
+            {
+                name: 'payload',
+                type: ARRAY(FIELD)
+            }
+        ],
+        returnType: ARRAY(FIELD)
     })
 };
-/**
- * Deserializes oracle inputs, calls the handler with typed params, and serializes the result.
- */ export async function callHandler({ oracle, inputs, handler }) {
-    const entry = ORACLE_REGISTRY[oracle];
-    const named = entry.deserializeParams(inputs);
-    const positional = named.map((p)=>p.value);
-    const result = await handler(positional);
-    return entry.serializeReturn(result);
-}
-function makeEntry({ params, returnType } = {}) {
+export function makeEntry({ params, returnType } = {}) {
     return {
+        params: params ?? [],
+        returnType,
         deserializeParams (inputs) {
             const resolvedParams = 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.
+                // 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: param.type.deserialization.fn(readers)
+                    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;
         },
         serializeReturn (result) {
             if (returnType?.serialization === undefined) {
@@ -1057,143 +1014,3 @@ function makeEntry({ params, returnType } = {}) {
         }
     };
 }
-/** `_height` is unused at runtime but lets TypeScript infer the exact `N` for `MembershipWitness<N>`. */ function MEMBERSHIP_WITNESS(_height) {
-    return {
-        serialization: {
-            fn: (witness)=>[
-                    new Fr(witness.leafIndex),
-                    [
-                        ...witness.siblingPath
-                    ]
-                ]
-        }
-    };
-}
-function ARRAY(element) {
-    return {
-        serialization: element.serialization ? {
-            fn: (values)=>[
-                    values.flatMap((v)=>element.serialization.fn(v).flat())
-                ]
-        } : undefined,
-        deserialization: element.deserialization ? {
-            fn: ([reader])=>{
-                const result = [];
-                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(element) {
-    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 = [];
-                for(let i = 0; i < length; i++){
-                    elements.push(element.deserialization.fn([
-                        storageReader
-                    ]));
-                }
-                return BoundedVec.from({
-                    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(inner) {
-    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(undefined);
-                }
-                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) {
-    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
-        }
-    };
-}