@aztec/pxe 0.0.1-commit.a5db02d → 0.0.1-commit.aa0c64f

package/src/bin/oracle_version_helpers.ts

@@ -1,75 +1,13 @@
-/* eslint-disable import-x/no-named-as-default-member */
 import { readFileSync } from 'fs';
-import ts from 'typescript';
 
-/**
- * Extracts method signatures from TypeScript classes or interfaces and returns a deterministic string representation.
- *
- * This is used to detect when an oracle interface changes so that the oracle version can be bumped. It works with both
- * class declarations (e.g. PXE's `Oracle` class) and interface declarations (e.g. TXE's `IAvmExecutionOracle`).
- *
- * @param sourcePath - Absolute path to the TypeScript source file to parse.
- * @param targets - Names of classes or interfaces to extract methods from.
- * @param excludedMembers - Method names to skip (e.g. non-oracle helpers like `constructor`).
- */
-export function getOracleInterfaceSignature(sourcePath: string, targets: string[], excludedMembers: string[]): string {
-  const sourceCode = readFileSync(sourcePath, 'utf-8');
-  const sourceFile = ts.createSourceFile(sourcePath, sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-
-  const methodSignatures: string[] = [];
-
-  function visit(node: ts.Node) {
-    const isTarget =
-      (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) && targets.includes(node.name?.text ?? '');
-
-    if (isTarget) {
-      node.members.forEach(member => {
-        if (
-          (ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) &&
-          member.name &&
-          ts.isIdentifier(member.name)
-        ) {
-          const methodName = member.name.text;
-
-          if (excludedMembers.includes(methodName)) {
-            return;
-          }
-
-          const paramSignatures: string[] = [];
-          member.parameters.forEach(param => {
-            const paramName = extractParameterName(param, sourceFile);
-            const paramType = extractTypeString(param.type, sourceFile);
-            paramSignatures.push(`${paramName}: ${paramType}`);
-          });
-
-          const returnType = extractTypeString(member.type, sourceFile);
-
-          const signature = `${methodName}(${paramSignatures.join(', ')}): ${returnType}`;
-          methodSignatures.push(signature);
-        }
-      });
-    }
-
-    ts.forEachChild(node, visit);
-  }
-
-  visit(sourceFile);
-
-  methodSignatures.sort();
-
-  return methodSignatures.join('');
-}
+import type { OracleRegistryEntry } from '../contract_function_simulator/index.js';
 
 /**
- * Extracts a deterministic signature string from an oracle registry object literal (e.g. PXE's `ORACLE_REGISTRY`).
- *
- * Reads the registry declaration where each oracle's wire ABI lives: the ordered parameter names with their
- * `TypeMapping` expressions and the return type. The resulting hash is sensitive to parameter, type, and return
- * changes, not just oracle additions and removals.
+ * Extracts a deterministic signature string from an oracle registry (e.g. PXE's `ORACLE_REGISTRY`).
  *
- * Type expressions are captured as their source text (e.g. `OPTION(AZTEC_ADDRESS)`, `BOUNDED_VEC(NOTE)`), so the
- * signature tracks the composition of types. However, if the internal serialization logic of a `TypeMapping` constant
- * (e.g. `FIELD`) changes without the constant being renamed, the hash will not change.
+ * Reads the registry where each oracle's wire ABI lives: the ordered parameter names with their `TypeMapping` labels
+ * and the return type. The resulting hash is sensitive to parameter, type, and return changes, not just oracle
+ * additions and removals.
  *
  * @example
  * // Given a registry like:
@@ -79,32 +17,13 @@ export function getOracleInterfaceSignature(sourcePath: string, targets: string[
  * //   } satisfies Record<string, OracleRegistryEntry>;
  * //
  * // Returns (sorted, newline-joined):
- * //   "aztec_prv_bar(): void\naztec_utl_foo(a: U32): BOOL"
- *
- * @param sourcePath - Absolute path to the TypeScript source file declaring the registry.
- * @param registryName - Name of the registry constant to read (e.g. `ORACLE_REGISTRY`).
+ * //   "aztec_prv_bar(): void\naztec_utl_foo(a: u32): bool"
  */
-export function getOracleRegistrySignature(sourcePath: string, registryName: string): string {
-  const sourceCode = readFileSync(sourcePath, 'utf-8');
-  const sourceFile = ts.createSourceFile(sourcePath, sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-
-  const registry = findObjectLiteral(sourceFile, registryName);
-  if (!registry) {
-    throw new Error(`Could not find oracle registry '${registryName}' in ${sourcePath}.`);
-  }
-
-  const oracleSignatures = registry.properties.map(property => {
-    if (!ts.isPropertyAssignment(property)) {
-      throw new Error(
-        `Unexpected member in oracle registry '${registryName}': ${property.getText(sourceFile)}. Spread elements ` +
-          `are not supported.`,
-      );
-    }
-
-    const oracleName = getPropertyName(property.name, sourceFile);
-    const { params, returnType } = extractRegistryEntry(property.initializer, sourceFile);
-    const paramSignatures = params.map(param => `${param.name}: ${param.type}`);
-    return `${oracleName}(${paramSignatures.join(', ')}): ${returnType}`;
+export function getOracleRegistrySignature(registry: Record<string, OracleRegistryEntry>): string {
+  const oracleSignatures = Object.entries(registry).map(([name, entry]) => {
+    const paramSignatures = entry.params.map(p => `${p.name}: ${p.type.label}`);
+    const returnType = entry.returnType === undefined ? 'void' : entry.returnType.label;
+    return `${name}(${paramSignatures.join(', ')}): ${returnType}`;
   });
 
   oracleSignatures.sort();
@@ -133,179 +52,3 @@ export function readNumericGlobal(sourcePath: string, name: string): number {
   }
   return Number(match[1]);
 }
-
-function extractParameterName(param: ts.ParameterDeclaration, sourceFile: ts.SourceFile): string {
-  const name = param.name;
-
-  if (ts.isIdentifier(name)) {
-    return name.text;
-  }
-
-  if (ts.isArrayBindingPattern(name)) {
-    if (name.elements.length > 0) {
-      const element = name.elements[0];
-      if (ts.isBindingElement(element)) {
-        const elementName = element.name;
-        if (ts.isIdentifier(elementName)) {
-          return elementName.text;
-        }
-        if (ts.isArrayBindingPattern(elementName) || ts.isObjectBindingPattern(elementName)) {
-          return elementName.getText(sourceFile);
-        }
-      }
-    }
-    return name.getText(sourceFile);
-  }
-
-  if (ts.isObjectBindingPattern(name)) {
-    return name.getText(sourceFile);
-  }
-
-  return (name as ts.Node).getText(sourceFile);
-}
-
-/** Returns the source text of a type annotation, or `'void'` if absent. */
-function extractTypeString(typeNode: ts.TypeNode | undefined, sourceFile: ts.SourceFile): string {
-  if (!typeNode) {
-    return 'void';
-  }
-
-  return typeNode.getText(sourceFile).replace(/\s+/g, ' ').trim();
-}
-
-/**
- * Finds a top-level object-literal-valued constant by name, unwrapping `satisfies`/`as`/parenthesized wrappers.
- *
- * @example
- * // `const REGISTRY = { ... } satisfies Record<string, Entry>` => the `{ ... }` ObjectLiteralExpression
- */
-function findObjectLiteral(sourceFile: ts.SourceFile, name: string): ts.ObjectLiteralExpression | undefined {
-  let result: ts.ObjectLiteralExpression | undefined;
-
-  function visit(node: ts.Node) {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === name && node.initializer) {
-      result = unwrapObjectLiteral(node.initializer);
-    }
-    ts.forEachChild(node, visit);
-  }
-
-  visit(sourceFile);
-  return result;
-}
-
-/** Peels `satisfies`, `as`, and parenthesized wrappers off an expression to reach the underlying object literal. */
-function unwrapObjectLiteral(node: ts.Expression): ts.ObjectLiteralExpression | undefined {
-  let current = node;
-  while (ts.isSatisfiesExpression(current) || ts.isAsExpression(current) || ts.isParenthesizedExpression(current)) {
-    current = current.expression;
-  }
-  return ts.isObjectLiteralExpression(current) ? current : undefined;
-}
-
-/**
- * Extracts the ordered `params` (names + type expressions) and `returnType` from a `makeEntry({ ... })` call.
- *
- * @example
- * // makeEntry({ params: [{ name: 'a', type: OPTION(FIELD) }], returnType: BOOL })
- * // => { params: [{ name: 'a', type: 'OPTION(FIELD)' }], returnType: 'BOOL' }
- * //
- * // makeEntry()
- * // => { params: [], returnType: 'void' }
- */
-function extractRegistryEntry(
-  initializer: ts.Expression,
-  sourceFile: ts.SourceFile,
-): { params: { name: string; type: string }[]; returnType: string } {
-  if (!ts.isCallExpression(initializer)) {
-    throw new Error(`Expected a makeEntry(...) call but got: ${initializer.getText(sourceFile)}`);
-  }
-
-  const [arg] = initializer.arguments;
-  if (arg === undefined) {
-    return { params: [], returnType: 'void' };
-  }
-  if (!ts.isObjectLiteralExpression(arg)) {
-    throw new Error(`Expected a makeEntry object argument but got: ${arg.getText(sourceFile)}`);
-  }
-
-  let params: { name: string; type: string }[] = [];
-  let returnType = 'void';
-
-  arg.properties.forEach(property => {
-    if (!ts.isPropertyAssignment(property)) {
-      throw new Error(`Unexpected makeEntry property: ${property.getText(sourceFile)}`);
-    }
-    const key = getPropertyName(property.name, sourceFile);
-    if (key === 'params') {
-      params = extractRegistryParams(property.initializer, sourceFile);
-    } else if (key === 'returnType') {
-      returnType = normalizeExpressionText(property.initializer, sourceFile);
-    } else {
-      throw new Error(`Unexpected makeEntry property '${key}'.`);
-    }
-  });
-
-  return { params, returnType };
-}
-
-/**
- * Extracts `{ name, type }` pairs from the `params` array literal inside a `makeEntry` call.
- */
-function extractRegistryParams(
-  initializer: ts.Expression,
-  sourceFile: ts.SourceFile,
-): { name: string; type: string }[] {
-  if (!ts.isArrayLiteralExpression(initializer)) {
-    throw new Error(`Expected a params array but got: ${initializer.getText(sourceFile)}`);
-  }
-
-  return initializer.elements.map(element => {
-    if (!ts.isObjectLiteralExpression(element)) {
-      throw new Error(`Expected a param object but got: ${element.getText(sourceFile)}`);
-    }
-
-    let name: string | undefined;
-    let type: string | undefined;
-    element.properties.forEach(property => {
-      if (!ts.isPropertyAssignment(property)) {
-        throw new Error(`Unexpected param property: ${property.getText(sourceFile)}`);
-      }
-      const key = getPropertyName(property.name, sourceFile);
-      if (key === 'name') {
-        if (!ts.isStringLiteralLike(property.initializer)) {
-          throw new Error(`Expected a string literal param name but got: ${property.initializer.getText(sourceFile)}`);
-        }
-        name = property.initializer.text;
-      } else if (key === 'type') {
-        type = normalizeExpressionText(property.initializer, sourceFile);
-      } else {
-        throw new Error(`Unexpected param property '${key}'.`);
-      }
-    });
-
-    if (name === undefined || type === undefined) {
-      throw new Error(`Param missing 'name' or 'type': ${element.getText(sourceFile)}`);
-    }
-    return { name, type };
-  });
-}
-
-/** Returns the text of an identifier or string-literal property name, throwing on computed or numeric names. */
-function getPropertyName(name: ts.PropertyName, sourceFile: ts.SourceFile): string {
-  if (ts.isIdentifier(name) || ts.isStringLiteralLike(name)) {
-    return name.text;
-  }
-  throw new Error(`Unsupported property name: ${name.getText(sourceFile)}`);
-}
-
-/**
- * Returns the source text of an expression with all whitespace stripped for format-insensitive comparison.
- *
- * @example
- * // `OPTION(\n  AZTEC_ADDRESS\n)` => `"OPTION(AZTEC_ADDRESS)"`
- */
-function normalizeExpressionText(node: ts.Expression, sourceFile: ts.SourceFile): string {
-  // Type expressions are TypeMapping references and calls (identifiers, parentheses, commas, numbers) with no
-  // meaningful whitespace, so we strip it entirely to keep the signature stable across reformatting.
-  return node.getText(sourceFile).replace(/\s+/g, '');
-}

package/src/config/package_info.ts

@@ -1,3 +1,3 @@
 export function getPackageInfo() {
-  return { version: '5.0.1', name: '@aztec/pxe' };
+  return { version: '6.0.0', name: '@aztec/pxe' };
 }

package/src/contract/helpers.ts

@@ -1,10 +1,10 @@
-import { isProtocolContract } from '@aztec/protocol-contracts';
 import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { ContractStore } from '../storage/contract_store/contract_store.js';
 import type { ContractClassService } from './contract_class_service.js';
+import { isSkipSyncContract } from './skip_sync_contracts.js';
 
 export async function syncScope(
   contractAddress: AztecAddress,
@@ -15,8 +15,8 @@ export async function syncScope(
   utilityExecutor: (privateSyncCall: FunctionCall, scopes: AztecAddress[]) => Promise<any>,
   scope: AztecAddress,
 ) {
-  // Protocol contracts don't have private state to sync
-  if (isProtocolContract(contractAddress)) {
+  // Some canonical contracts hold no private state, so there is nothing to sync (see `skipSyncContracts`).
+  if (isSkipSyncContract(contractAddress)) {
     return;
   }
 

package/src/contract/skip_sync_contracts.ts

@@ -0,0 +1,23 @@
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { STANDARD_AUTH_REGISTRY_ADDRESS } from '@aztec/standard-contracts/auth-registry/constants';
+import { STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS } from '@aztec/standard-contracts/multi-call-entrypoint/constants';
+import { STANDARD_PUBLIC_CHECKS_ADDRESS } from '@aztec/standard-contracts/public-checks/constants';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+/**
+ * Canonical contracts that hold no private state and are therefore never synced.
+ *
+ * The protocol contracts (registries, fee juice) plus the standard AuthRegistry, MultiCallEntrypoint and PublicChecks
+ * declare no notes and no events, so their macro-generated `sync_state` has nothing to discover.
+ */
+export const skipSyncContracts: AztecAddress[] = [
+  ...Object.values(ProtocolContractAddress),
+  STANDARD_AUTH_REGISTRY_ADDRESS,
+  STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS,
+  STANDARD_PUBLIC_CHECKS_ADDRESS,
+];
+
+/** Returns whether the given contract should be skipped during private state synchronization. */
+export function isSkipSyncContract(address: AztecAddress): boolean {
+  return skipSyncContracts.some(a => a.equals(address));
+}

package/src/contract_function_simulator/contract_function_simulator.ts

@@ -1,3 +1,4 @@
+import { CircuitKind } from '@aztec/bb.js';
 import {
   AVM_EMITNOTEHASH_BASE_L2_GAS,
   AVM_EMITNULLIFIER_BASE_L2_GAS,
@@ -314,7 +315,7 @@ export class ContractFunctionSimulator {
       );
       const simulatorTeardownTimer = new Timer();
 
-      const firstNullifier = noteCache.getNonceGenerator();
+      const firstNullifierHint = noteCache.getNonceGenerator();
 
       const publicCallRequests = collectNested([executionResult], r =>
         r.publicInputs.publicCallRequests
@@ -337,9 +338,9 @@ export class ContractFunctionSimulator {
       }
 
       // Not to be confused with a PrivateCallExecutionResult. This is a superset
-      // of the PrivateCallExecutionResult, containing also firstNullifier
+      // of the PrivateCallExecutionResult, containing also firstNullifierHint
       // and publicFunctionsCalldata.
-      return new PrivateExecutionResult(executionResult, firstNullifier, publicFunctionsCalldata);
+      return new PrivateExecutionResult(executionResult, firstNullifierHint, publicFunctionsCalldata);
     } catch (err) {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }
@@ -587,6 +588,7 @@ export async function generateSimulatedProvingResult(
         execution.publicInputs.callContext.functionSelector,
       ),
       timings: execution.profileResult?.timings ?? { witgen: 0, oracles: {} },
+      kind: CircuitKind.App,
       bytecode: execution.acir,
       vk: execution.vk,
       witness: execution.partialWitness,

package/src/contract_function_simulator/index.ts

@@ -6,6 +6,7 @@ export {
   type ParamTypes,
 } from './oracle/oracle_registry.js';
 export {
+  ALIAS,
   ARRAY,
   AZTEC_ADDRESS,
   BIGINT,
@@ -13,8 +14,7 @@ export {
   BLOCK_NUMBER,
   BOOL,
   BOUNDED_VEC,
-  BUFFER,
-  BYTE,
+  U8,
   CONTRACT_INSTANCE,
   DELIVERY_MODE,
   EPHEMERAL_ARRAY,
@@ -23,6 +23,8 @@ export {
   FIELD,
   FIXED_ARRAY,
   FUNCTION_SELECTOR,
+  LEAF,
+  LEAF_INDEX,
   LOG_RETRIEVAL_REQUEST,
   LOG_RETRIEVAL_RESPONSE,
   MEMBERSHIP_WITNESS,
@@ -32,16 +34,34 @@ export {
   PENDING_TAGGED_LOG,
   POINT,
   PROVIDED_SECRET,
+  SCALAR,
   SLOT_NUMBER,
   STR,
   STRUCT,
   U32,
+  U64,
+  U128,
   tryFieldWidth,
+  isArrayMapping,
+  isBoundedVecMapping,
+  isEphemeralArrayMapping,
+  isFixedArrayMapping,
+  isFixedBoundedVecMapping,
+  isOptionMapping,
+  isStructMapping,
+  type ArrayMapping,
+  type BoundedVecMapping,
+  type CompositeMapping,
+  type EphemeralArrayMapping,
+  type FixedArrayMapping,
+  type FixedBoundedVecMapping,
   type InputSlot,
   type MaybePromise,
+  type OptionMapping,
   type OutputSlot,
   type SlotShape,
   type StructField,
+  type StructMapping,
   type TypeMapping,
 } from './oracle/oracle_type_mappings.js';
 export { ExecutionNoteCache } from './execution_note_cache.js';
@@ -74,5 +94,5 @@ export { NoteValidationRequest } from './noir-structs/note_validation_request.js
 export type { PendingTaggedLog } from './noir-structs/pending_tagged_log.js';
 export type { TxEffectData } from './noir-structs/tx_effect_data.js';
 export type { ProvidedSecret } from './noir-structs/provided_secret.js';
-export { ResolvedTx } from './noir-structs/resolved_tx.js';
+export type { ResolvedTx } from './noir-structs/resolved_tx.js';
 export { TransientArrayService } from './transient_array_service.js';

package/src/contract_function_simulator/noir-structs/resolved_tx.ts

@@ -1,7 +1,5 @@
-import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { TxHash } from '@aztec/stdlib/tx';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { TxHash } from '@aztec/stdlib/tx';
 
 /**
  * The resolved on-chain context of a transaction.
@@ -9,45 +7,13 @@ import { TxHash } from '@aztec/stdlib/tx';
  * Carries the note hashes and first nullifier needed to discover notes that originated from the transaction, plus the
  * number and hash of the block in which it was mined.
  *
- * A TS version of the `ResolvedTx` struct in `oracle/tx_resolution.nr`.
+ * A TS version of the `ResolvedTx` struct in `oracle/tx_resolution.nr`; its wire layout lives in the `RESOLVED_TX`
+ * type mapping.
  */
-export class ResolvedTx {
-  constructor(
-    public txHash: TxHash,
-    public uniqueNoteHashesInTx: Fr[],
-    public firstNullifierInTx: Fr,
-    public blockNumber: number,
-    public blockHash: Fr,
-  ) {}
-
-  toFields(): Fr[] {
-    return [
-      this.txHash.hash,
-      ...serializeBoundedVec(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
-      this.firstNullifierInTx,
-      new Fr(this.blockNumber),
-      this.blockHash,
-    ];
-  }
-
-  static empty(): ResolvedTx {
-    return new ResolvedTx(TxHash.zero(), [], Fr.ZERO, 0, Fr.ZERO);
-  }
-}
-
-/**
- * Helper function to serialize a bounded vector according to Noir's BoundedVec format: the storage array padded to
- * `maxLength`, followed by the actual length.
- * @param values - The values to serialize
- * @param maxLength - The maximum length of the bounded vector
- * @returns The serialized bounded vector as Fr[]
- */
-function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
-  const storage = padArrayEnd(
-    values,
-    Fr.ZERO,
-    maxLength,
-    `Attempted to serialize ${values} values into a BoundedVec with max length ${maxLength}`,
-  );
-  return [...storage, new Fr(values.length)];
-}
+export type ResolvedTx = {
+  txHash: TxHash;
+  uniqueNoteHashesInTx: Fr[];
+  firstNullifierInTx: Fr;
+  blockNumber: number;
+  blockHash: Fr;
+};

package/src/contract_function_simulator/noir-structs/tx_effect_data.ts

@@ -6,10 +6,11 @@ import type { ContractClassLogData } from './contract_class_log_data.js';
 
 /**
  * Wire form of a {@link TxEffect} as the `getTxEffect` oracle returns it: identical to the domain type except its logs
- * are flattened to their Noir layout. Keeping the conversion in the handler lets the `TX_EFFECT` mapping stay purely
- * structural.
+ * are flattened to their Noir layout and its revert code is the plain `u8` Noir declares. Keeping the conversion in
+ * the handler lets the `TX_EFFECT` mapping stay purely structural.
  */
-export type TxEffectData = Omit<FieldsOf<TxEffect>, 'publicLogs' | 'contractClassLogs'> & {
+export type TxEffectData = Omit<FieldsOf<TxEffect>, 'revertCode' | 'publicLogs' | 'contractClassLogs'> & {
+  revertCode: number;
   publicLogs: FlatPublicLogs;
   contractClassLogs: ContractClassLogData[];
 };

package/src/contract_function_simulator/oracle/oracle_registry.ts

@@ -13,8 +13,6 @@ import {
   BLOCK_NUMBER,
   BOOL,
   BOUNDED_VEC,
-  BUFFER,
-  BYTE,
   CALL_PRIVATE_RESULT,
   CONTRACT_CLASS_LOG,
   CONTRACT_INSTANCE,
@@ -23,6 +21,7 @@ import {
   EVENT_VALIDATION_REQUEST,
   FACT_COLLECTION,
   FIELD,
+  FIXED_ARRAY,
   FUNCTION_SELECTOR,
   type InputSlot,
   KEY_VALIDATION_REQUEST,
@@ -50,6 +49,7 @@ import {
   TX_EFFECT,
   TX_HASH,
   type TypeMapping,
+  U8,
   U32,
   UTILITY_CONTEXT,
   assertReadersConsumed,
@@ -63,8 +63,7 @@ export {
   BLOCK_NUMBER,
   BOOL,
   BOUNDED_VEC,
-  BUFFER,
-  BYTE,
+  U8,
   CONTRACT_CLASS_LOG,
   DELIVERY_MODE,
   RESOLVED_TAGGING_STRATEGY,
@@ -317,11 +316,11 @@ export const ORACLE_REGISTRY = {
 
   aztec_utl_decryptAes128: makeEntry({
     params: [
-      { name: 'ciphertext', type: BOUNDED_VEC(BYTE) },
-      { name: 'iv', type: BUFFER(8, 16) },
-      { name: 'symKey', type: BUFFER(8, 16) },
+      { 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({