@aztec-labs/aztec.js 6.0.0-nightly.20260829

package/src/fee/private_fee_payment_method.ts

@@ -0,0 +1,145 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import {
+  type FunctionAbi,
+  FunctionCall,
+  FunctionSelector,
+  FunctionType,
+  decodeFromAbi,
+  getFunctionReturnType,
+} from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { GasSettings } from '@aztec-labs/stdlib/gas';
+import { ExecutionPayload } from '@aztec-labs/stdlib/tx';
+
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { NO_FROM } from '../contract/interaction_options.js';
+import type { Wallet } from '../wallet/wallet.js';
+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;
+
+  constructor(
+    /**
+     * Address which will hold the fee payment.
+     */
+    private paymentContract: AztecAddress,
+
+    /**
+     * Address of the account that will pay the fee
+     */
+    private sender: AztecAddress,
+
+    /**
+     * A wallet to perform the simulation to get the accepted asset
+     */
+    private wallet: Wallet,
+    /**
+     * Gas settings used to compute the maximum fee the user is willing to pay
+     */
+    protected gasSettings: GasSettings,
+    /**
+     * If true, the max fee will be set to 1.
+     * TODO(#7694): Remove this param once the lacking feature in TXE is implemented.
+     */
+    private setMaxFeeToOne = false,
+  ) {}
+
+  /**
+   * The asset used to pay the fee.
+   * @returns The asset used to pay the fee.
+   */
+  async getAsset(): Promise<AztecAddress> {
+    if (!this.assetPromise) {
+      const abi = {
+        name: 'get_accepted_asset',
+        functionType: FunctionType.PRIVATE,
+        isOnlySelf: false,
+        isStatic: false,
+        parameters: [],
+        returnType: {
+          kind: 'struct',
+          path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
+          fields: [
+            {
+              name: 'inner',
+              type: {
+                kind: 'field',
+              },
+            },
+          ],
+        },
+        errorTypes: {},
+        isInitializer: false,
+      } as FunctionAbi;
+      const interaction = new ContractFunctionInteraction(this.wallet, this.paymentContract, abi, []);
+
+      const executionPayload = await interaction.request();
+      this.assetPromise = this.wallet
+        .simulateTx(executionPayload, {
+          from: NO_FROM,
+          skipFeeEnforcement: true,
+        })
+        .then(simulationResult => {
+          const rawReturnValues = simulationResult.getPrivateReturnValues().values;
+          return decodeFromAbi(getFunctionReturnType(abi), rawReturnValues!);
+        }) as Promise<AztecAddress>;
+    }
+    return this.assetPromise!;
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return Promise.resolve(this.paymentContract);
+  }
+
+  /**
+   * Creates an execution payload to pay the fee using a private function through an FPC in the desired asset
+   * @param gasSettings - The gas settings.
+   * @returns An execution payload that contains the required function calls and auth witnesses.
+   */
+  async getExecutionPayload(): Promise<ExecutionPayload> {
+    // We assume 1:1 exchange rate between fee juice and token. But in reality you would need to convert feeLimit
+    // (maxFee) to be in token denomination.
+    const maxFee = this.setMaxFeeToOne ? Fr.ONE : this.gasSettings.getFeeLimit();
+    const txNonce = Fr.random();
+
+    const witness = await this.wallet.createAuthWit(this.sender, {
+      caller: this.paymentContract,
+      call: FunctionCall.from({
+        name: 'transfer_to_public',
+        to: await this.getAsset(),
+        selector: await FunctionSelector.fromSignature('transfer_to_public((Field),(Field),u128,Field)'),
+        type: FunctionType.PRIVATE,
+        hideMsgSender: false,
+        isStatic: false,
+        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
+      }),
+    });
+
+    return new ExecutionPayload(
+      [
+        FunctionCall.from({
+          name: 'fee_entrypoint_private',
+          to: this.paymentContract,
+          selector: await FunctionSelector.fromSignature('fee_entrypoint_private(u128,Field)'),
+          type: FunctionType.PRIVATE,
+          hideMsgSender: false,
+          isStatic: false,
+          args: [maxFee, txNonce],
+        }),
+      ],
+      [witness],
+      [],
+      [],
+      this.paymentContract, // feePayer
+    );
+  }
+
+  getGasSettings(): GasSettings | undefined {
+    return this.gasSettings;
+  }
+}

package/src/fee/public_fee_payment_method.ts

@@ -0,0 +1,145 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import {
+  type FunctionAbi,
+  FunctionCall,
+  FunctionSelector,
+  FunctionType,
+  decodeFromAbi,
+  getFunctionReturnType,
+} from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { GasSettings } from '@aztec-labs/stdlib/gas';
+import { ExecutionPayload } from '@aztec-labs/stdlib/tx';
+
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { NO_FROM } from '../contract/interaction_options.js';
+import { SetPublicAuthwitContractInteraction } from '../utils/authwit.js';
+import type { Wallet } from '../wallet/wallet.js';
+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;
+
+  constructor(
+    /**
+     * Address which will hold the fee payment.
+     */
+    protected paymentContract: AztecAddress,
+    /**
+     * An auth witness provider to authorize fee payments
+     */
+    protected sender: AztecAddress,
+    /**
+     * A wallet to perform the simulation to get the accepted asset
+     */
+    protected wallet: Wallet,
+    /**
+     * Gas settings used to compute the maximum fee the user is willing to pay
+     */
+    protected gasSettings: GasSettings,
+  ) {}
+
+  /**
+   * The asset used to pay the fee.
+   * @returns The asset used to pay the fee.
+   */
+  async getAsset(): Promise<AztecAddress> {
+    if (!this.assetPromise) {
+      const abi = {
+        name: 'get_accepted_asset',
+        functionType: FunctionType.PRIVATE,
+        isOnlySelf: false,
+        isStatic: false,
+        parameters: [],
+        returnType: {
+          kind: 'struct',
+          path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
+          fields: [
+            {
+              name: 'inner',
+              type: {
+                kind: 'field',
+              },
+            },
+          ],
+        },
+        errorTypes: {},
+        isInitializer: false,
+      } as FunctionAbi;
+      const interaction = new ContractFunctionInteraction(this.wallet, this.paymentContract, abi, []);
+
+      const executionPayload = await interaction.request();
+      this.assetPromise = this.wallet
+        .simulateTx(executionPayload, {
+          from: NO_FROM,
+          skipFeeEnforcement: true,
+        })
+        .then(simulationResult => {
+          const rawReturnValues = simulationResult.getPrivateReturnValues().values;
+          return decodeFromAbi(getFunctionReturnType(abi), rawReturnValues!);
+        }) as Promise<AztecAddress>;
+    }
+    return this.assetPromise!;
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return Promise.resolve(this.paymentContract);
+  }
+
+  /**
+   * Creates an execution payload to pay the fee using a public function through an FPC in the desired asset
+   * @param gasSettings - The gas settings.
+   * @returns An execution payload that contains the required function calls.
+   */
+  async getExecutionPayload(): Promise<ExecutionPayload> {
+    const txNonce = Fr.random();
+    const maxFee = this.gasSettings.getFeeLimit();
+
+    const intent = {
+      caller: this.paymentContract,
+      call: FunctionCall.from({
+        name: 'transfer_in_public',
+        to: await this.getAsset(),
+        selector: await FunctionSelector.fromSignature('transfer_in_public((Field),(Field),u128,Field)'),
+        type: FunctionType.PUBLIC,
+        hideMsgSender: false /** The target function performs an authwit check, so msg_sender is needed */,
+        isStatic: false,
+        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
+      }),
+    };
+
+    const setPublicAuthWitInteraction = await SetPublicAuthwitContractInteraction.create(
+      this.wallet,
+      this.sender,
+      intent,
+      true,
+    );
+
+    return new ExecutionPayload(
+      [
+        ...(await setPublicAuthWitInteraction.request()).calls,
+        FunctionCall.from({
+          name: 'fee_entrypoint_public',
+          to: this.paymentContract,
+          selector: await FunctionSelector.fromSignature('fee_entrypoint_public(u128,Field)'),
+          type: FunctionType.PRIVATE,
+          hideMsgSender: false,
+          isStatic: false,
+          args: [maxFee, txNonce],
+        }),
+      ],
+      [],
+      [],
+      [],
+      this.paymentContract, // feePayer
+    );
+  }
+
+  getGasSettings(): GasSettings | undefined {
+    return this.gasSettings;
+  }
+}

package/src/fee/sponsored_fee_payment.ts

@@ -0,0 +1,45 @@
+import type { FeePaymentMethod } from '@aztec-labs/aztec.js/fee';
+import { FunctionCall, FunctionSelector, FunctionType } from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { GasSettings } from '@aztec-labs/stdlib/gas';
+import { ExecutionPayload } from '@aztec-labs/stdlib/tx';
+
+/**
+ * A fee payment method that uses a contract that blindly sponsors transactions.
+ * This contract is expected to be prefunded in testing environments.
+ */
+export class SponsoredFeePaymentMethod implements FeePaymentMethod {
+  constructor(private paymentContract: AztecAddress) {}
+
+  getAsset(): Promise<AztecAddress> {
+    throw new Error('Asset is not required for sponsored fpc.');
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return Promise.resolve(this.paymentContract);
+  }
+
+  async getExecutionPayload(): Promise<ExecutionPayload> {
+    return new ExecutionPayload(
+      [
+        FunctionCall.from({
+          name: 'sponsor_unconditionally',
+          to: this.paymentContract,
+          selector: await FunctionSelector.fromSignature('sponsor_unconditionally()'),
+          type: FunctionType.PRIVATE,
+          hideMsgSender: false,
+          isStatic: false,
+          args: [],
+        }),
+      ],
+      [],
+      [],
+      [],
+      this.paymentContract, // feePayer
+    );
+  }
+
+  getGasSettings(): GasSettings | undefined {
+    return;
+  }
+}

package/src/scripts/generate_protocol_contract_types.ts

@@ -0,0 +1,160 @@
+/**
+ * Generates type-safe contract wrappers for protocol contracts.
+ * These wrappers use a minimal artifact (without bytecode) since PXE already has the full artifacts registered.
+ */
+import { generateTypescriptContractInterface } from '@aztec-labs/builder/codegen';
+import { fileURLToPath } from '@aztec-labs/foundation/url';
+import {
+  type ContractArtifact,
+  type FunctionAbi,
+  FunctionType,
+  getAllFunctionAbis,
+  getFunctionReturnType,
+  loadContractArtifact,
+} from '@aztec-labs/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec-labs/stdlib/noir';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+const log = console.log;
+
+const artifactsPkgRoot = path.dirname(
+  fileURLToPath(import.meta.resolve('@aztec/protocol-contracts-artifacts/package.json')),
+);
+const srcPath = path.join(artifactsPkgRoot, 'artifacts');
+const outputDir = path.join(import.meta.dirname, '../contract/protocol_contracts');
+
+function toKebabCase(str: string): string {
+  return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+
+function functionTypeToEnum(type: FunctionType): string {
+  switch (type) {
+    case FunctionType.PRIVATE:
+      return 'FunctionType.PRIVATE';
+    case FunctionType.PUBLIC:
+      return 'FunctionType.PUBLIC';
+    case FunctionType.UTILITY:
+      return 'FunctionType.UTILITY';
+  }
+}
+
+function generateFunctionAbiJson(abi: FunctionAbi): string {
+  const baseObj = {
+    name: abi.name,
+    isOnlySelf: abi.isOnlySelf,
+    isStatic: abi.isStatic,
+    isInitializer: abi.isInitializer,
+    parameters: abi.parameters,
+    returnType: getFunctionReturnType(abi),
+    errorTypes: abi.errorTypes,
+  };
+  const jsonStr = JSON.stringify(baseObj);
+  return jsonStr.replace('{', `{ functionType: ${functionTypeToEnum(abi.functionType)},`);
+}
+
+function generateProtocolContractArtifact(input: ContractArtifact): string {
+  const allAbis = getAllFunctionAbis(input);
+  const functionAbis = input.functions.map(f => allAbis.find(abi => abi.name === f.name)!);
+  const nonDispatchAbis = input.nonDispatchPublicFunctions;
+
+  const functionsArray = functionAbis
+    .map(abi => `{ ...${generateFunctionAbiJson(abi)}, bytecode: Buffer.from([]), debugSymbols: '' }`)
+    .join(',\n    ');
+
+  const nonDispatchArray = nonDispatchAbis.map(abi => generateFunctionAbiJson(abi)).join(',\n    ');
+
+  return `{
+  name: '${input.name}',
+  aztecVersion: '${input.aztecVersion}',
+  functions: [
+    ${functionsArray}
+  ],
+  nonDispatchPublicFunctions: [
+    ${nonDispatchArray}
+  ],
+  outputs: { structs: {}, globals: {} },
+  storageLayout: {},
+  fileMap: {},
+}`;
+}
+
+async function generateProtocolContractInterface(
+  input: ContractArtifact,
+  protocolContractName: string,
+): Promise<string> {
+  const baseInterface = await generateTypescriptContractInterface(input);
+
+  // Match everything between "public declare methods: {" and the closing "};"
+  const methodsMatch = baseInterface.match(/public declare methods: \{([\s\S]*?)\n  \};/);
+  if (!methodsMatch) {
+    throw new Error('Could not extract methods from generated interface');
+  }
+
+  const artifactCode = generateProtocolContractArtifact(input);
+  const contractName = `${input.name}Contract`;
+
+  return `
+/* Autogenerated file, do not edit! */
+
+/* eslint-disable */
+import { ProtocolContractAddress } from '@aztec-labs/protocol-contracts';
+import { FunctionType } from '@aztec-labs/stdlib/abi';
+
+import type { ContractArtifact } from '../../api/abi.js';
+import { PublicKeys } from '../../api/keys.js';
+import type { AztecAddressLike, EthAddressLike, FieldLike, FunctionSelectorLike, OptionLike, WrappedFieldLike } from '../../utils/abi_types.js';
+import { ContractBase, type ContractMethod } from '../contract_base.js';
+import { ContractFunctionInteraction } from '../contract_function_interaction.js';
+import type { Wallet } from '../../wallet/wallet.js';
+
+const ${contractName}Artifact: ContractArtifact = ${artifactCode};
+
+export class ${contractName} extends ContractBase {
+  private constructor(wallet: Wallet) {
+    super(ProtocolContractAddress.${protocolContractName}, ${contractName}Artifact, wallet);
+  }
+
+  /** Returns an interface to the canonical ${contractName} instance, bound to the given wallet. */
+  public static withWallet(wallet: Wallet): ${contractName} {
+    return new ${contractName}(wallet);
+  }
+
+  /** @deprecated Use \`withWallet\` instead. */
+  public static at(wallet: Wallet): ${contractName} {
+    return ${contractName}.withWallet(wallet);
+  }
+
+  public declare methods: {${methodsMatch[1]}
+  };
+}
+`;
+}
+
+async function main() {
+  await fs.rm(outputDir, { recursive: true, force: true });
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const srcNames = JSON.parse(
+    await fs.readFile(path.join(artifactsPkgRoot, 'protocol_contracts.json'), 'utf8'),
+  ) as string[];
+
+  for (const srcName of srcNames) {
+    // srcName is like "auth_registry_contract-AuthRegistry", split to get the contract name
+    const name = srcName.split('-')[1];
+    const artifactPath = path.join(srcPath, `${srcName}.json`);
+    const json = JSON.parse(await fs.readFile(artifactPath, 'utf8')) as NoirCompiledContract;
+    const contractArtifact = loadContractArtifact(json);
+
+    const content = await generateProtocolContractInterface(contractArtifact, name);
+    const fileName = `${toKebabCase(name)}.ts`;
+    await fs.writeFile(path.join(outputDir, fileName), content);
+
+    log(`Generated ${fileName}`);
+  }
+}
+
+main().catch(err => {
+  console.error('Error generating protocol contract types:', err);
+  process.exit(1);
+});

package/src/test/fixtures.ts

@@ -0,0 +1,126 @@
+import { MEGA_APP_VK_LENGTH_IN_FIELDS } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type ContractArtifact, FunctionType } from '@aztec-labs/stdlib/abi';
+import { DEV_VERSION } from '@aztec-labs/stdlib/update-checker';
+
+/**
+ * A minimal but representative `ContractArtifact` shared by unit tests in this package. Covers
+ * every function shape the tests exercise: a private initializer (`constructor`), the standard
+ * `public_dispatch` entry, a private function with mixed-visibility params (`bar`), a utility
+ * function (`qux`), and two functions exercising Noir `Option<Field>` parameters (`optionEcho`,
+ * `mixedParams`).
+ *
+ * We deliberately do not depend on `@aztec-labs/noir-test-contracts.js` here: that package depends on
+ * `@aztec-labs/aztec.js`, so importing from it would create a workspace cycle.
+ */
+export const testContractArtifact: ContractArtifact = {
+  name: 'TestContract',
+  aztecVersion: DEV_VERSION,
+  functions: [
+    {
+      name: 'constructor',
+      isInitializer: true,
+      functionType: FunctionType.PRIVATE,
+      isOnlySelf: false,
+      isStatic: false,
+      debugSymbols: '',
+      parameters: [],
+      errorTypes: {},
+      bytecode: Buffer.alloc(8, 0xfa),
+      verificationKey: Buffer.alloc(MEGA_APP_VK_LENGTH_IN_FIELDS * Fr.SIZE_IN_BYTES).toString('base64'),
+    },
+    {
+      name: 'public_dispatch',
+      isInitializer: false,
+      isStatic: false,
+      functionType: FunctionType.PUBLIC,
+      isOnlySelf: false,
+      parameters: [{ name: 'selector', type: { kind: 'field' }, visibility: 'public' }],
+      errorTypes: {},
+      bytecode: Buffer.alloc(8, 0xfb),
+      debugSymbols: '',
+    },
+    {
+      name: 'bar',
+      isInitializer: false,
+      functionType: FunctionType.PRIVATE,
+      isOnlySelf: false,
+      isStatic: false,
+      debugSymbols: '',
+      parameters: [
+        { name: 'value', type: { kind: 'field' }, visibility: 'public' },
+        { name: 'value', type: { kind: 'field' }, visibility: 'private' },
+      ],
+      errorTypes: {},
+      bytecode: Buffer.alloc(8, 0xfa),
+      verificationKey: Buffer.alloc(MEGA_APP_VK_LENGTH_IN_FIELDS * Fr.SIZE_IN_BYTES).toString('base64'),
+    },
+    {
+      name: 'qux',
+      isInitializer: false,
+      isStatic: false,
+      functionType: FunctionType.UTILITY,
+      isOnlySelf: false,
+      parameters: [{ name: 'value', type: { kind: 'field' }, visibility: 'public' }],
+      returnType: { kind: 'integer', sign: 'unsigned', width: 32 },
+      bytecode: Buffer.alloc(8, 0xfc),
+      debugSymbols: '',
+      errorTypes: {},
+    },
+    {
+      name: 'optionEcho',
+      isInitializer: false,
+      functionType: FunctionType.PRIVATE,
+      isOnlySelf: false,
+      isStatic: false,
+      parameters: [
+        {
+          name: 'value',
+          type: {
+            kind: 'struct',
+            path: 'std::option::Option',
+            fields: [
+              { name: '_is_some', type: { kind: 'boolean' } },
+              { name: '_value', type: { kind: 'field' } },
+            ],
+          },
+          visibility: 'private',
+        },
+      ],
+      errorTypes: {},
+      bytecode: Buffer.alloc(8, 0xfd),
+      verificationKey: Buffer.alloc(MEGA_APP_VK_LENGTH_IN_FIELDS * Fr.SIZE_IN_BYTES).toString('base64'),
+      debugSymbols: '',
+    },
+    {
+      name: 'mixedParams',
+      isInitializer: false,
+      functionType: FunctionType.PRIVATE,
+      isOnlySelf: false,
+      isStatic: false,
+      parameters: [
+        {
+          name: 'optValue',
+          type: {
+            kind: 'struct',
+            path: 'std::option::Option',
+            fields: [
+              { name: '_is_some', type: { kind: 'boolean' } },
+              { name: '_value', type: { kind: 'field' } },
+            ],
+          },
+          visibility: 'private',
+        },
+        { name: 'aField', type: { kind: 'field' }, visibility: 'private' },
+      ],
+      errorTypes: {},
+      bytecode: Buffer.alloc(8, 0xfe),
+      verificationKey: Buffer.alloc(MEGA_APP_VK_LENGTH_IN_FIELDS * Fr.SIZE_IN_BYTES).toString('base64'),
+      debugSymbols: '',
+    },
+  ],
+  nonDispatchPublicFunctions: [],
+  outputs: { structs: {}, globals: {} },
+  fileMap: {},
+  storageLayout: {},
+};

package/src/utils/abi_types.ts

@@ -0,0 +1,32 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { EventSelector, FunctionSelector } from '@aztec-labs/stdlib/abi';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+
+/** Any type that can be converted into a field for a contract call. */
+export type FieldLike = Fr | Buffer | bigint | number | { /** Converts to field */ toField: () => Fr };
+
+/** Any type that can be converted into an EthAddress Aztec.nr struct. */
+export type EthAddressLike = { /** Wrapped address */ address: FieldLike } | EthAddress;
+
+/** Any type that can be converted into an AztecAddress Aztec.nr struct. */
+export type AztecAddressLike = { /** Wrapped address */ address: FieldLike } | AztecAddress;
+
+/** Any type that can be converted into a FunctionSelector Aztec.nr struct. */
+export type FunctionSelectorLike = FieldLike | FunctionSelector;
+
+/** Any type that can be converted into an EventSelector Aztec.nr struct. */
+export type EventSelectorLike = FieldLike | EventSelector;
+
+/** Any type that can be converted into a U128. */
+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 };