@aztec/aztec.js 0.0.1-commit.27d773e65 → 0.0.1-commit.2c85e299c

package/src/contract/contract_function_interaction.ts

@@ -1,14 +1,18 @@
 import {
+  type ABIParameter,
+  type AbiType,
   type FunctionAbi,
   FunctionCall,
   FunctionSelector,
   FunctionType,
+  canBeMappedFromNullOrUndefined,
   decodeFromAbi,
   encodeArguments,
+  isOptionStruct,
 } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type Capsule, type HashedValues, type TxProfileResult, collectOffchainEffects } from '@aztec/stdlib/tx';
+import type { Capsule, HashedValues, TxProfileResult } from '@aztec/stdlib/tx';
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 
 import type { Wallet } from '../wallet/wallet.js';
@@ -18,7 +22,9 @@ import {
   type ProfileInteractionOptions,
   type RequestInteractionOptions,
   type SimulateInteractionOptions,
-  type SimulationReturn,
+  type SimulationResult,
+  emptyOffchainOutput,
+  extractOffchainOutput,
   toProfileOptions,
   toSimulateOptions,
 } from './interaction_options.js';
@@ -38,11 +44,32 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     private extraHashedArgs: HashedValues[] = [],
   ) {
     super(wallet, authWitnesses, capsules);
-    if (args.some(arg => arg === undefined || arg === null)) {
-      throw new Error(`All function interaction arguments must be defined and not null. Received: ${args}`);
+    // This may feel a bit ad-hoc here, so it warrants a comment. We accept Noir Option<T> parameters, and it's natural
+    // to map JS's null/undefined to Noir Option's None. One possible way to deal with null/undefined arguments at this
+    // point in the codebase is to conclude that they are accepted since at least one Noir type (ie: Option) can be
+    // encoded from them. Then we would let `encode` deal with potential mismatches. I chose not to do that because of
+    // the pervasiveness of null/undefined in JS, and how easy it is to inadvertently pass it around. Having this check
+    // here allows us to fail at a point where the boundaries and intent are clear.
+    if (this.hasInvalidNullOrUndefinedArguments(args)) {
+      const signature = formatFunctionSignature(this.functionDao.name, this.functionDao.parameters);
+      const received = args.map(formatArg).join(', ');
+      throw new Error(
+        `Null or undefined arguments are only allowed for Option<T> parameters in ${signature}. Received: (${received}).`,
+      );
     }
   }
 
+  private hasInvalidNullOrUndefinedArguments(args: any[]) {
+    return args.some((arg, index) => {
+      if (arg !== undefined && arg !== null) {
+        return false;
+      }
+
+      const parameterType = this.functionDao.parameters[index]?.type;
+      return !parameterType || !canBeMappedFromNullOrUndefined(parameterType);
+    });
+  }
+
   /**
    * Returns the encoded function call wrapped by this interaction
    * Useful when generating authwits
@@ -97,17 +124,9 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
    * function or a rich object containing extra metadata, such as estimated gas costs (if requested via options),
    * execution statistics and emitted offchain effects
    */
-  public async simulate<T extends SimulateInteractionOptions>(
-    options: T,
-  ): Promise<SimulationReturn<Exclude<T['fee'], undefined>['estimateGas']>>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
-  public async simulate<T extends SimulateInteractionOptions>(
-    options: T,
-  ): Promise<SimulationReturn<T['includeMetadata']>>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
   public async simulate(
-    options: SimulateInteractionOptions,
-  ): Promise<SimulationReturn<typeof options.includeMetadata>> {
+    options: SimulateInteractionOptions = {} as SimulateInteractionOptions,
+  ): Promise<SimulationResult> {
     // docs:end:simulate
     if (this.functionDao.functionType == FunctionType.UTILITY) {
       const call = await this.getFunctionCall();
@@ -122,11 +141,11 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
       if (options.includeMetadata) {
         return {
           stats: utilityResult.stats,
+          ...emptyOffchainOutput(),
           result: returnValue,
         };
-      } else {
-        return returnValue;
       }
+      return { result: returnValue, ...emptyOffchainOutput() };
     }
 
     const executionPayload = await this.request(options);
@@ -148,6 +167,7 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     }
 
     const returnValue = rawReturnValues ? decodeFromAbi(this.functionDao.returnTypes, rawReturnValues) : [];
+    const offchainOutput = extractOffchainOutput(simulatedTx.offchainEffects);
 
     if (options.includeMetadata || options.fee?.estimateGas) {
       const { gasLimits, teardownGasLimits } = getGasLimits(simulatedTx, options.fee?.estimatedGasPadding);
@@ -156,13 +176,12 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
       );
       return {
         stats: simulatedTx.stats,
-        offchainEffects: collectOffchainEffects(simulatedTx.privateExecutionResult),
+        ...offchainOutput,
         result: returnValue,
         estimatedGas: { gasLimits, teardownGasLimits },
       };
-    } else {
-      return returnValue;
     }
+    return { result: returnValue, ...offchainOutput };
   }
 
   /**
@@ -210,3 +229,62 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     );
   }
 }
+
+/**
+ *  Render an AbiType as a human readable string
+ * */
+function formatAbiType(abiType: AbiType): string {
+  switch (abiType.kind) {
+    case 'field':
+      return 'Field';
+    case 'boolean':
+      return 'bool';
+    case 'integer':
+      return `${abiType.sign === 'signed' ? 'i' : 'u'}${abiType.width}`;
+    case 'string':
+      return `str<${abiType.length}>`;
+    case 'array':
+      return `[${formatAbiType(abiType.type)}; ${abiType.length}]`;
+    case 'struct': {
+      if (isOptionStruct(abiType)) {
+        const innerType = abiType.fields.find(f => f.name === '_value')!.type;
+        return `Option<${formatAbiType(innerType)}>`;
+      }
+      return `(${abiType.fields.map(f => `${f.name}: ${formatAbiType(f.type)}`).join(', ')})`;
+    }
+    case 'tuple':
+      return `(${abiType.fields.map(formatAbiType).join(', ')})`;
+  }
+}
+
+/**
+ * Pretty print a function signature
+ */
+function formatFunctionSignature(name: string, parameters: ABIParameter[]): string {
+  const params = parameters.map(p => `${p.name}: ${formatAbiType(p.type)}`).join(', ');
+  return `${name}(${params})`;
+}
+
+/**
+ * Non-exhaustive pretty print of JS args to display in error messages in this module
+ */
+function formatArg(arg: unknown): string {
+  if (arg === undefined) {
+    return 'undefined';
+  }
+  if (arg === null) {
+    return 'null';
+  }
+  if (typeof arg === 'bigint') {
+    return `${arg}n`;
+  }
+  if (Array.isArray(arg)) {
+    return `[${arg.map(formatArg).join(', ')}]`;
+  }
+  if (typeof arg === 'object') {
+    const entries = Object.entries(arg).map(([k, v]) => `${k}: ${formatArg(v)}`);
+    return `{ ${entries.join(', ')} }`;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-base-to-string
+  return String(arg);
+}

package/src/contract/deploy_method.ts

@@ -9,14 +9,7 @@ import {
   getContractInstanceFromInstantiationParams,
 } from '@aztec/stdlib/contract';
 import type { PublicKeys } from '@aztec/stdlib/keys';
-import {
-  type Capsule,
-  HashedValues,
-  TxHash,
-  type TxProfileResult,
-  type TxReceipt,
-  collectOffchainEffects,
-} from '@aztec/stdlib/tx';
+import { type Capsule, HashedValues, type TxProfileResult, type TxReceipt } from '@aztec/stdlib/tx';
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 
 import { publishContractClass } from '../deployment/publish_class.js';
@@ -29,11 +22,15 @@ import { getGasLimits } from './get_gas_limits.js';
 import {
   NO_WAIT,
   type NoWait,
+  type OffchainOutput,
   type ProfileInteractionOptions,
   type RequestInteractionOptions,
   type SendInteractionOptionsWithoutWait,
   type SimulationInteractionFeeOptions,
-  type SimulationReturn,
+  type SimulationResult,
+  type TxSendResultImmediate,
+  type TxSendResultMined,
+  extractOffchainOutput,
   toProfileOptions,
   toSendOptions,
   toSimulateOptions,
@@ -130,20 +127,32 @@ export type DeployTxReceipt<TContract extends ContractBase = ContractBase> = TxR
   instance: ContractInstanceWithAddress;
 };
 
+/** Wait options that request a full receipt instead of just the contract instance. */
+type WaitWithReturnReceipt = {
+  /** Request the full receipt instead of just the contract instance. */
+  returnReceipt: true;
+};
+
 /**
  * Represents the result type of deploying a contract.
  * - If wait is NO_WAIT, returns TxHash immediately.
  * - If wait has returnReceipt: true, returns DeployTxReceipt after waiting.
  * - Otherwise (undefined or DeployWaitOptions without returnReceipt), returns TContract after waiting.
  */
+/** Result of deploying a contract when waiting for mining (default case). */
+export type DeployResultMined<TContract extends ContractBase> = {
+  /** The deployed contract instance. */
+  contract: TContract;
+  /** The deploy transaction receipt. */
+  receipt: DeployTxReceipt<TContract>;
+} & OffchainOutput;
+
+/** Conditional return type for deploy based on wait options. */
 export type DeployReturn<TContract extends ContractBase, W extends DeployInteractionWaitOptions> = W extends NoWait
-  ? TxHash
-  : W extends {
-        // eslint-disable-next-line jsdoc/require-jsdoc
-        returnReceipt: true;
-      }
-    ? DeployTxReceipt<TContract>
-    : TContract;
+  ? TxSendResultImmediate
+  : W extends WaitWithReturnReceipt
+    ? TxSendResultMined<DeployTxReceipt<TContract>>
+    : DeployResultMined<TContract>;
 
 /**
  * Contract interaction for deployment.
@@ -343,8 +352,7 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
    * @returns TxHash (if wait is NO_WAIT), TContract (if wait is undefined or doesn't have returnReceipt), or DeployTxReceipt (if wait.returnReceipt is true)
    */
   // Overload for when wait is not specified at all - returns the contract
-  public override send(options: DeployOptionsWithoutWait): Promise<TContract>;
-  // Generic overload for explicit wait values
+  public override send(options: DeployOptionsWithoutWait): Promise<DeployResultMined<TContract>>;
   // eslint-disable-next-line jsdoc/require-jsdoc
   public override send<W extends DeployInteractionWaitOptions>(
     options: DeployOptions<W>,
@@ -355,12 +363,15 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
     const sendOptions = this.convertDeployOptionsToSendOptions(options);
 
     if (options.wait === NO_WAIT) {
-      const txHash = await this.wallet.sendTx(executionPayload, sendOptions as SendOptions<NoWait>);
-      this.log.debug(`Sent deployment tx ${txHash.hash} of ${this.artifact.name} contract`);
-      return txHash;
+      const result = await this.wallet.sendTx(executionPayload, sendOptions as SendOptions<NoWait>);
+      this.log.debug(`Sent deployment tx ${result.txHash.hash} of ${this.artifact.name} contract`);
+      return result;
     }
 
-    const receipt = await this.wallet.sendTx(executionPayload, sendOptions as SendOptions<WaitOpts | undefined>);
+    const { receipt, ...offchainOutput } = await this.wallet.sendTx(
+      executionPayload,
+      sendOptions as SendOptions<WaitOpts | undefined>,
+    );
     this.log.debug(`Deployed ${this.artifact.name} contract in tx ${receipt.txHash}`);
 
     // Attach contract instance
@@ -369,10 +380,10 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
 
     // Return full receipt if requested, otherwise just the contract
     if (options.wait && typeof options.wait === 'object' && options.wait.returnReceipt) {
-      return { ...receipt, contract, instance };
+      return { receipt: { ...receipt, contract, instance }, ...offchainOutput };
     }
 
-    return contract;
+    return { contract, receipt, ...offchainOutput };
   }
 
   /**
@@ -401,7 +412,7 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
    * @returns A simulation result object containing metadata of the execution, including gas
    * estimations (if requested via options), execution statistics and emitted offchain effects
    */
-  public async simulate(options: SimulateDeployOptions): Promise<SimulationReturn<true>> {
+  public async simulate(options: SimulateDeployOptions): Promise<SimulationResult> {
     const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
     const simulatedTx = await this.wallet.simulateTx(
       executionPayload,
@@ -414,7 +425,7 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
     );
     return {
       stats: simulatedTx.stats!,
-      offchainEffects: collectOffchainEffects(simulatedTx.privateExecutionResult),
+      ...extractOffchainOutput(simulatedTx.offchainEffects),
       result: undefined,
       estimatedGas: { gasLimits, teardownGasLimits },
     };

package/src/contract/interaction_options.ts

@@ -1,8 +1,16 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { FieldsOf } from '@aztec/foundation/types';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
-import type { Capsule, OffchainEffect, SimulationStats, TxHash, TxReceipt } from '@aztec/stdlib/tx';
+import {
+  type Capsule,
+  OFFCHAIN_MESSAGE_IDENTIFIER,
+  type OffchainEffect,
+  type SimulationStats,
+  type TxHash,
+  type TxReceipt,
+} from '@aztec/stdlib/tx';
 
 import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
 import type { ProfileOptions, SendOptions, SimulateOptions } from '../wallet/index.js';
@@ -116,8 +124,8 @@ export type SimulateInteractionOptions = Omit<SendInteractionOptions, 'fee'> & {
   skipTxValidation?: boolean;
   /** Whether to ensure the fee payer is not empty and has enough balance to pay for the fee. */
   skipFeeEnforcement?: boolean;
-  /** Whether to include metadata such as offchain effects and performance statistics (e.g. timing information of the different circuits and oracles) in
-   * the simulation result, instead of just the return value of the function */
+  /** Whether to include metadata such as performance statistics (e.g. timing information of the different circuits and oracles) and gas estimation
+   * in the simulation result, in addition to the return value and offchain effects */
   includeMetadata?: boolean;
 };
 
@@ -131,31 +139,89 @@ export type ProfileInteractionOptions = SimulateInteractionOptions & {
   skipProofGeneration?: boolean;
 };
 
+/** A message emitted during execution or proving, to be delivered offchain. */
+export type OffchainMessage = {
+  /** The intended recipient of the message. */
+  recipient: AztecAddress;
+  /** The message payload (typically encrypted). */
+  payload: Fr[];
+  /** The contract that emitted the message. */
+  contractAddress: AztecAddress;
+};
+
+/** Groups all unproven outputs from private execution that are returned to the client. */
+export type OffchainOutput = {
+  /** Raw offchain effects emitted during execution. */
+  offchainEffects: OffchainEffect[];
+  /** Messages emitted during execution, to be delivered offchain. */
+  offchainMessages: OffchainMessage[];
+};
+
 /**
- * Represents the result type of a simulation.
- * By default, it will just be the return value of the simulated function
- * If `includeMetadata` is set to true in `SimulateInteractionOptions` on the input of `simulate(...)`,
- * it will provide extra information.
- */
-export type SimulationReturn<T extends boolean | undefined> = T extends true
-  ? {
-      /** Additional stats about the simulation */
-      stats: SimulationStats;
-      /** Offchain effects generated during the simulation */
-      offchainEffects: OffchainEffect[];
-      /**  Return value of the function */
-      result: any;
-      /** Gas estimation results */
-      estimatedGas: Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>;
+ * Splits an array of offchain effects into decoded offchain messages and remaining effects.
+ * Effects whose data starts with `OFFCHAIN_MESSAGE_IDENTIFIER` are parsed as messages and removed
+ * from the effects array.
+ */
+export function extractOffchainOutput(effects: OffchainEffect[]): OffchainOutput {
+  const offchainEffects: OffchainEffect[] = [];
+  const offchainMessages: OffchainMessage[] = [];
+
+  for (const effect of effects) {
+    if (effect.data.length >= 2 && effect.data[0].equals(OFFCHAIN_MESSAGE_IDENTIFIER)) {
+      offchainMessages.push({
+        recipient: AztecAddress.fromField(effect.data[1]),
+        payload: effect.data.slice(2),
+        contractAddress: effect.contractAddress,
+      });
+    } else {
+      offchainEffects.push(effect);
     }
-  : any;
+  }
+
+  return { offchainEffects, offchainMessages };
+}
+
+/**
+ * Returns an empty `OffchainOutput` (no effects, no messages).
+ */
+export function emptyOffchainOutput(): OffchainOutput {
+  return { offchainEffects: [], offchainMessages: [] };
+}
+
+/**
+ * Represents the result of a simulation.
+ * Always includes the return value and offchain output.
+ * When `includeMetadata` or `fee.estimateGas` is set, also includes stats and gas estimation.
+ */
+export type SimulationResult = {
+  /** Return value of the function */
+  result: any;
+  /** Additional stats about the simulation. Present when `includeMetadata` is set. */
+  stats?: SimulationStats;
+  /** Gas estimation results. Present when `includeMetadata` or `fee.estimateGas` is set. */
+  estimatedGas?: Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>;
+} & OffchainOutput;
+
+/** Result of sendTx when not waiting for mining. */
+export type TxSendResultImmediate = {
+  /** The hash of the sent transaction. */
+  txHash: TxHash;
+} & OffchainOutput;
+
+/** Result of sendTx when waiting for mining. */
+export type TxSendResultMined<TReturn = TxReceipt> = {
+  /** The transaction receipt. */
+  receipt: TReturn;
+} & OffchainOutput;
 
 /**
  * Represents the result type of sending a transaction.
- * If `wait` is NO_WAIT, returns TxHash immediately without waiting.
- * If `wait` is undefined or WaitOpts, returns TReturn (defaults to TxReceipt) after waiting.
+ * If `wait` is NO_WAIT, returns TxSendResultImmediate.
+ * Otherwise returns TxSendResultMined.
  */
-export type SendReturn<T extends InteractionWaitOptions, TReturn = TxReceipt> = T extends NoWait ? TxHash : TReturn;
+export type SendReturn<T extends InteractionWaitOptions, TReturn = TxReceipt> = T extends NoWait
+  ? TxSendResultImmediate
+  : TxSendResultMined<TReturn>;
 
 /**
  * Transforms and cleans up the higher level SendInteractionOptions defined by the interaction into

package/src/contract/protocol_contracts/auth-registry.ts

@@ -163,6 +163,7 @@ const AuthRegistryContractArtifact: ContractArtifact = {
           '4261968856572588300': { error_kind: 'string', string: 'Value does not fit in field' },
           '4440399188109668273': { error_kind: 'string', string: 'Input length must be a multiple of 32' },
           '5417577161503694006': { error_kind: 'fmtstring', length: 56, item_types: [{ kind: 'field' }] },
+          '5421095327929394772': { error_kind: 'string', string: 'attempt to bit-shift with overflow' },
           '9530675838293881722': { error_kind: 'string', string: 'Writer did not write all data' },
           '9791669845391776238': {
             error_kind: 'string',
@@ -266,6 +267,7 @@ const AuthRegistryContractArtifact: ContractArtifact = {
           '4261968856572588300': { error_kind: 'string', string: 'Value does not fit in field' },
           '4440399188109668273': { error_kind: 'string', string: 'Input length must be a multiple of 32' },
           '5417577161503694006': { error_kind: 'fmtstring', length: 56, item_types: [{ kind: 'field' }] },
+          '5421095327929394772': { error_kind: 'string', string: 'attempt to bit-shift with overflow' },
           '9530675838293881722': { error_kind: 'string', string: 'Writer did not write all data' },
           '9791669845391776238': {
             error_kind: 'string',

package/src/contract/protocol_contracts/fee-juice.ts

@@ -44,6 +44,7 @@ const FeeJuiceContractArtifact: ContractArtifact = {
         errorTypes: {
           '361444214588792908': { error_kind: 'string', string: 'attempt to multiply with overflow' },
           '1998584279744703196': { error_kind: 'string', string: 'attempt to subtract with overflow' },
+          '5421095327929394772': { error_kind: 'string', string: 'attempt to bit-shift with overflow' },
           '6609888949476313245': { error_kind: 'string', string: 'Message not in state' },
           '11019205087382408538': { error_kind: 'string', string: 'Field failed to decompose into specified 4 limbs' },
           '12370419938245003393': { error_kind: 'string', string: 'Field failed to decompose into specified 36 limbs' },
@@ -81,6 +82,7 @@ const FeeJuiceContractArtifact: ContractArtifact = {
         errorTypes: {
           '361444214588792908': { error_kind: 'string', string: 'attempt to multiply with overflow' },
           '1998584279744703196': { error_kind: 'string', string: 'attempt to subtract with overflow' },
+          '5421095327929394772': { error_kind: 'string', string: 'attempt to bit-shift with overflow' },
           '6609888949476313245': { error_kind: 'string', string: 'Message not in state' },
           '11019205087382408538': { error_kind: 'string', string: 'Field failed to decompose into specified 4 limbs' },
           '12370419938245003393': { error_kind: 'string', string: 'Field failed to decompose into specified 36 limbs' },

package/src/contract/protocol_contracts/multi-call-entrypoint.ts

@@ -161,6 +161,7 @@ const MultiCallEntrypointContractArtifact: ContractArtifact = {
           '4261968856572588300': { error_kind: 'string', string: 'Value does not fit in field' },
           '4440399188109668273': { error_kind: 'string', string: 'Input length must be a multiple of 32' },
           '5417577161503694006': { error_kind: 'fmtstring', length: 56, item_types: [{ kind: 'field' }] },
+          '5421095327929394772': { error_kind: 'string', string: 'attempt to bit-shift with overflow' },
           '9530675838293881722': { error_kind: 'string', string: 'Writer did not write all data' },
           '9791669845391776238': {
             error_kind: 'string',
@@ -225,6 +226,7 @@ const MultiCallEntrypointContractArtifact: ContractArtifact = {
           '4261968856572588300': { error_kind: 'string', string: 'Value does not fit in field' },
           '4440399188109668273': { error_kind: 'string', string: 'Input length must be a multiple of 32' },
           '5417577161503694006': { error_kind: 'fmtstring', length: 56, item_types: [{ kind: 'field' }] },
+          '5421095327929394772': { error_kind: 'string', string: 'attempt to bit-shift with overflow' },
           '9530675838293881722': { error_kind: 'string', string: 'Writer did not write all data' },
           '9791669845391776238': {
             error_kind: 'string',

package/src/contract/protocol_contracts/public-checks.ts

@@ -94,6 +94,7 @@ const PublicChecksContractArtifact: ContractArtifact = {
           '4261968856572588300': { error_kind: 'string', string: 'Value does not fit in field' },
           '4440399188109668273': { error_kind: 'string', string: 'Input length must be a multiple of 32' },
           '5417577161503694006': { error_kind: 'fmtstring', length: 56, item_types: [{ kind: 'field' }] },
+          '5421095327929394772': { error_kind: 'string', string: 'attempt to bit-shift with overflow' },
           '9530675838293881722': { error_kind: 'string', string: 'Writer did not write all data' },
           '9791669845391776238': {
             error_kind: 'string',
@@ -186,6 +187,7 @@ const PublicChecksContractArtifact: ContractArtifact = {
           '4261968856572588300': { error_kind: 'string', string: 'Value does not fit in field' },
           '4440399188109668273': { error_kind: 'string', string: 'Input length must be a multiple of 32' },
           '5417577161503694006': { error_kind: 'fmtstring', length: 56, item_types: [{ kind: 'field' }] },
+          '5421095327929394772': { error_kind: 'string', string: 'attempt to bit-shift with overflow' },
           '9530675838293881722': { error_kind: 'string', string: 'Writer did not write all data' },
           '9791669845391776238': {
             error_kind: 'string',

package/src/fee/private_fee_payment_method.ts

@@ -10,6 +10,7 @@ import type { FeePaymentMethod } from './fee_payment_method.js';
 
 /**
  * Holds information about how the fee for a transaction is to be paid.
+ * @deprecated Is not supported on mainnet. Use {@link FeeJuicePaymentMethodWithClaim} or `SponsoredFeePaymentMethod` instead.
  */
 export class PrivateFeePaymentMethod implements FeePaymentMethod {
   private assetPromise: Promise<AztecAddress> | null = null;

package/src/fee/public_fee_payment_method.ts

@@ -11,6 +11,7 @@ import type { FeePaymentMethod } from './fee_payment_method.js';
 
 /**
  * Holds information about how the fee for a transaction is to be paid.
+ * @deprecated Is not supported on mainnet. Use {@link FeeJuicePaymentMethodWithClaim} or `SponsoredFeePaymentMethod` instead.
  */
 export class PublicFeePaymentMethod implements FeePaymentMethod {
   private assetPromise: Promise<AztecAddress> | null = null;

package/src/utils/abi_types.ts

@@ -23,3 +23,10 @@ export type U128Like = bigint | number;
 
 /** Any type that can be converted into a struct with a single `inner` field. */
 export type WrappedFieldLike = { /** Wrapped value */ inner: FieldLike } | FieldLike;
+
+/** Noir `Option<T>` lowered ABI shape, plus ergonomic direct `T | null | undefined` inputs. */
+export type OptionLike<T> =
+  | T
+  | null
+  | undefined
+  | { /** Whether the option is populated */ _is_some: boolean; /** Wrapped value */ _value: T };

package/src/utils/authwit.ts

@@ -5,7 +5,7 @@ import { type ABIParameterVisibility, type FunctionAbi, type FunctionCall, Funct
 import { AuthWitness, computeInnerAuthWitHash, computeOuterAuthWitHash } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computeVarArgsHash } from '@aztec/stdlib/hash';
-import type { TxHash, TxProfileResult, TxReceipt } from '@aztec/stdlib/tx';
+import type { TxProfileResult } from '@aztec/stdlib/tx';
 
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
 import type {
@@ -15,7 +15,8 @@ import type {
   SendInteractionOptionsWithoutWait,
   SendReturn,
   SimulateInteractionOptions,
-  SimulationReturn,
+  SimulationResult,
+  TxSendResultMined,
 } from '../contract/interaction_options.js';
 import type { Wallet } from '../wallet/index.js';
 
@@ -189,10 +190,12 @@ export async function lookupValidity(
     errorTypes: {},
   } as FunctionAbi;
   try {
-    results.isValidInPrivate = (await new ContractFunctionInteraction(wallet, onBehalfOf, lookupValidityAbi, [
-      consumer,
-      innerHash,
-    ]).simulate({ from: onBehalfOf, authWitnesses: [witness] })) as boolean;
+    results.isValidInPrivate = (
+      await new ContractFunctionInteraction(wallet, onBehalfOf, lookupValidityAbi, [consumer, innerHash]).simulate({
+        from: onBehalfOf,
+        authWitnesses: [witness],
+      })
+    ).result as boolean;
     // TODO: Narrow down the error to make sure simulation failed due to an invalid authwit
     // eslint-disable-next-line no-empty
   } catch {}
@@ -219,12 +222,12 @@ export async function lookupValidity(
     returnTypes: [{ kind: 'boolean' }],
     errorTypes: {},
   } as FunctionAbi;
-  results.isValidInPublic = (await new ContractFunctionInteraction(
-    wallet,
-    ProtocolContractAddress.AuthRegistry,
-    isConsumableAbi,
-    [onBehalfOf, messageHash],
-  ).simulate({ from: onBehalfOf })) as boolean;
+  results.isValidInPublic = (
+    await new ContractFunctionInteraction(wallet, ProtocolContractAddress.AuthRegistry, isConsumableAbi, [
+      onBehalfOf,
+      messageHash,
+    ]).simulate({ from: onBehalfOf })
+  ).result as boolean;
 
   return results;
 }
@@ -262,14 +265,10 @@ export class SetPublicAuthwitContractInteraction extends ContractFunctionInterac
    * @param options - An optional object containing additional configuration for the transaction.
    * @returns The result of the transaction as returned by the contract function.
    */
-  public override simulate<T extends SimulateInteractionOptions>(
-    options: Omit<T, 'from'>,
-  ): Promise<SimulationReturn<T['includeMetadata']>>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
   public override simulate(
-    options: Omit<SimulateInteractionOptions, 'from'> = {},
-  ): Promise<SimulationReturn<typeof options.includeMetadata>> {
-    return super.simulate({ ...options, from: this.from });
+    options: Omit<SimulateInteractionOptions, 'from'> = {} as Omit<SimulateInteractionOptions, 'from'>,
+  ): Promise<SimulationResult> {
+    return super.simulate({ ...options, from: this.from } as SimulateInteractionOptions);
   }
 
   /**
@@ -290,8 +289,7 @@ export class SetPublicAuthwitContractInteraction extends ContractFunctionInterac
    * @param options - An optional object containing 'fee' options information
    * @returns A TxReceipt (if wait is true/undefined) or TxHash (if wait is false)
    */
-  // Overload for when wait is not specified at all - returns TxReceipt
-  public override send(options?: Omit<SendInteractionOptionsWithoutWait, 'from'>): Promise<TxReceipt>;
+  public override send(options?: Omit<SendInteractionOptionsWithoutWait, 'from'>): Promise<TxSendResultMined>;
   // Generic overload for explicit wait values
   // eslint-disable-next-line jsdoc/require-jsdoc
   public override send<W extends InteractionWaitOptions>(
@@ -300,7 +298,7 @@ export class SetPublicAuthwitContractInteraction extends ContractFunctionInterac
   // eslint-disable-next-line jsdoc/require-jsdoc
   public override send(
     options?: Omit<SendInteractionOptions<InteractionWaitOptions>, 'from'>,
-  ): Promise<TxReceipt | TxHash> {
+  ): Promise<SendReturn<InteractionWaitOptions>> {
     return super.send({ ...options, from: this.from });
   }