@aztec/aztec.js 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/fee/private_fee_payment_method.ts

@@ -1,11 +1,11 @@
-import { Fr } from '@aztec/foundation/fields';
-import { type FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type FunctionAbi, FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/wallet.js';
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { SignerlessWallet } from '../wallet/signerless_wallet.js';
+import type { Wallet } from '../wallet/wallet.js';
 import type { FeePaymentMethod } from './fee_payment_method.js';
 
 /**
@@ -21,10 +21,18 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
     private paymentContract: AztecAddress,
 
     /**
-     * An auth witness provider to authorize fee payments
+     * Address of the account that will pay the fee
      */
-    private wallet: Wallet,
+    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.
@@ -36,41 +44,43 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
    * The asset used to pay the fee.
    * @returns The asset used to pay the fee.
    */
-  getAsset(): Promise<AztecAddress> {
+  async getAsset(): Promise<AztecAddress> {
     if (!this.assetPromise) {
-      // We use signer-less wallet because this function could be triggered before the associated account is deployed.
-      const signerlessWallet = new SignerlessWallet(this.wallet);
-
-      const interaction = new ContractFunctionInteraction(
-        signerlessWallet,
-        this.paymentContract,
-        {
-          name: 'get_accepted_asset',
-          functionType: FunctionType.PRIVATE,
-          isInternal: false,
-          isStatic: false,
-          parameters: [],
-          returnTypes: [
-            {
-              kind: 'struct',
-              path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
-              fields: [
-                {
-                  name: 'inner',
-                  type: {
-                    kind: 'field',
-                  },
+      const abi = {
+        name: 'get_accepted_asset',
+        functionType: FunctionType.PRIVATE,
+        isOnlySelf: false,
+        isStatic: false,
+        parameters: [],
+        returnTypes: [
+          {
+            kind: 'struct',
+            path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
+            fields: [
+              {
+                name: 'inner',
+                type: {
+                  kind: 'field',
                 },
-              ],
-            },
-          ],
-          errorTypes: {},
-          isInitializer: false,
-        },
-        [],
-      );
+              },
+            ],
+          },
+        ],
+        errorTypes: {},
+        isInitializer: false,
+      } as FunctionAbi;
+      const interaction = new ContractFunctionInteraction(this.wallet, this.paymentContract, abi, []);
 
-      this.assetPromise = interaction.simulate();
+      const executionPayload = await interaction.request();
+      this.assetPromise = this.wallet
+        .simulateTx(executionPayload, {
+          from: AztecAddress.ZERO,
+          skipFeeEnforcement: true,
+        })
+        .then(simulationResult => {
+          const rawReturnValues = simulationResult.getPrivateReturnValues().nested[0].values;
+          return decodeFromAbi(abi.returnTypes, rawReturnValues!);
+        }) as Promise<AztecAddress>;
     }
     return this.assetPromise!;
   }
@@ -80,39 +90,51 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
   }
 
   /**
-   * Creates a function call to pay the fee in the given asset.
+   * 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 The function call to pay the fee.
+   * @returns An execution payload that contains the required function calls and auth witnesses.
    */
-  async getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
+  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 : gasSettings.getFeeLimit();
-    const nonce = Fr.random();
+    const maxFee = this.setMaxFeeToOne ? Fr.ONE : this.gasSettings.getFeeLimit();
+    const txNonce = Fr.random();
 
-    await this.wallet.createAuthWit({
+    const witness = await this.wallet.createAuthWit(this.sender, {
       caller: this.paymentContract,
-      action: {
+      call: {
         name: 'transfer_to_public',
-        args: [this.wallet.getAddress().toField(), this.paymentContract.toField(), maxFee, nonce],
+        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
         selector: await FunctionSelector.fromSignature('transfer_to_public((Field),(Field),u128,Field)'),
         type: FunctionType.PRIVATE,
+        hideMsgSender: false,
         isStatic: false,
         to: await this.getAsset(),
         returnTypes: [],
       },
     });
 
-    return [
-      {
-        name: 'fee_entrypoint_private',
-        to: this.paymentContract,
-        selector: await FunctionSelector.fromSignature('fee_entrypoint_private(u128,Field)'),
-        type: FunctionType.PRIVATE,
-        isStatic: false,
-        args: [maxFee, nonce],
-        returnTypes: [],
-      },
-    ];
+    return new ExecutionPayload(
+      [
+        {
+          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],
+          returnTypes: [],
+        },
+      ],
+      [witness],
+      [],
+      [],
+      this.paymentContract, // feePayer
+    );
+  }
+
+  getGasSettings(): GasSettings | undefined {
+    return this.gasSettings;
   }
 }

package/src/fee/public_fee_payment_method.ts

@@ -1,12 +1,12 @@
-import { Fr } from '@aztec/foundation/fields';
-import type { FunctionCall } from '@aztec/stdlib/abi';
-import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { GasSettings } from '@aztec/stdlib/gas';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type FunctionAbi, FunctionSelector, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload } from '@aztec/stdlib/tx';
 
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import type { AccountWallet } from '../wallet/account_wallet.js';
-import { SignerlessWallet } from '../wallet/signerless_wallet.js';
+import { SetPublicAuthwitContractInteraction } from '../utils/authwit.js';
+import type { Wallet } from '../wallet/wallet.js';
 import type { FeePaymentMethod } from './fee_payment_method.js';
 
 /**
@@ -23,48 +23,58 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
     /**
      * An auth witness provider to authorize fee payments
      */
-    protected wallet: AccountWallet,
+    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.
    */
-  getAsset(): Promise<AztecAddress> {
+  async getAsset(): Promise<AztecAddress> {
     if (!this.assetPromise) {
-      // We use signer-less wallet because this function could be triggered before the associated account is deployed.
-      const signerlessWallet = new SignerlessWallet(this.wallet);
-
-      const interaction = new ContractFunctionInteraction(
-        signerlessWallet,
-        this.paymentContract,
-        {
-          name: 'get_accepted_asset',
-          functionType: FunctionType.PRIVATE,
-          isInternal: false,
-          isStatic: false,
-          parameters: [],
-          returnTypes: [
-            {
-              kind: 'struct',
-              path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
-              fields: [
-                {
-                  name: 'inner',
-                  type: {
-                    kind: 'field',
-                  },
+      const abi = {
+        name: 'get_accepted_asset',
+        functionType: FunctionType.PRIVATE,
+        isOnlySelf: false,
+        isStatic: false,
+        parameters: [],
+        returnTypes: [
+          {
+            kind: 'struct',
+            path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
+            fields: [
+              {
+                name: 'inner',
+                type: {
+                  kind: 'field',
                 },
-              ],
-            },
-          ],
-          errorTypes: {},
-          isInitializer: false,
-        },
-        [],
-      );
+              },
+            ],
+          },
+        ],
+        errorTypes: {},
+        isInitializer: false,
+      } as FunctionAbi;
+      const interaction = new ContractFunctionInteraction(this.wallet, this.paymentContract, abi, []);
 
-      this.assetPromise = interaction.simulate();
+      const executionPayload = await interaction.request();
+      this.assetPromise = this.wallet
+        .simulateTx(executionPayload, {
+          from: AztecAddress.ZERO,
+          skipFeeEnforcement: true,
+        })
+        .then(simulationResult => {
+          const rawReturnValues = simulationResult.getPrivateReturnValues().nested[0].values;
+          return decodeFromAbi(abi.returnTypes, rawReturnValues!);
+        }) as Promise<AztecAddress>;
     }
     return this.assetPromise!;
   }
@@ -74,41 +84,57 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
   }
 
   /**
-   * Creates a function call to pay the fee in the given asset.
+   * 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 The function call to pay the fee.
+   * @returns An execution payload that contains the required function calls.
    */
-  async getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
-    const nonce = Fr.random();
-    const maxFee = gasSettings.getFeeLimit();
+  async getExecutionPayload(): Promise<ExecutionPayload> {
+    const txNonce = Fr.random();
+    const maxFee = this.gasSettings.getFeeLimit();
 
-    const setPublicAuthWitInteraction = await this.wallet.setPublicAuthWit(
-      {
-        caller: this.paymentContract,
-        action: {
-          name: 'transfer_in_public',
-          args: [this.wallet.getAddress().toField(), this.paymentContract.toField(), maxFee, nonce],
-          selector: await FunctionSelector.fromSignature('transfer_in_public((Field),(Field),u128,Field)'),
-          type: FunctionType.PUBLIC,
+    const intent = {
+      caller: this.paymentContract,
+      call: {
+        name: 'transfer_in_public',
+        args: [this.sender.toField(), this.paymentContract.toField(), maxFee, txNonce],
+        selector: await FunctionSelector.fromSignature('transfer_in_public((Field),(Field),u128,Field)'),
+        type: FunctionType.PUBLIC,
+        isStatic: false,
+        hideMsgSender: false /** The target function performs an authwit check, so msg_sender is needed */,
+        to: await this.getAsset(),
+        returnTypes: [],
+      },
+    };
+
+    const setPublicAuthWitInteraction = await SetPublicAuthwitContractInteraction.create(
+      this.wallet,
+      this.sender,
+      intent,
+      true,
+    );
+
+    return new ExecutionPayload(
+      [
+        ...(await setPublicAuthWitInteraction.request()).calls,
+        {
+          name: 'fee_entrypoint_public',
+          to: this.paymentContract,
+          selector: await FunctionSelector.fromSignature('fee_entrypoint_public(u128,Field)'),
+          type: FunctionType.PRIVATE,
+          hideMsgSender: false,
           isStatic: false,
-          to: await this.getAsset(),
+          args: [maxFee, txNonce],
           returnTypes: [],
         },
-      },
-      true,
+      ],
+      [],
+      [],
+      [],
+      this.paymentContract, // feePayer
     );
+  }
 
-    return [
-      await setPublicAuthWitInteraction.request(),
-      {
-        name: 'fee_entrypoint_public',
-        to: this.paymentContract,
-        selector: await FunctionSelector.fromSignature('fee_entrypoint_public(u128,Field)'),
-        type: FunctionType.PRIVATE,
-        isStatic: false,
-        args: [maxFee, nonce],
-        returnTypes: [],
-      },
-    ];
+  getGasSettings(): GasSettings | undefined {
+    return this.gasSettings;
   }
 }

package/src/fee/sponsored_fee_payment.ts

@@ -0,0 +1,46 @@
+import type { FeePaymentMethod } from '@aztec/aztec.js/fee';
+import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload } from '@aztec/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() {
+    return Promise.resolve(this.paymentContract);
+  }
+
+  async getExecutionPayload(): Promise<ExecutionPayload> {
+    return new ExecutionPayload(
+      [
+        {
+          name: 'sponsor_unconditionally',
+          to: this.paymentContract,
+          selector: await FunctionSelector.fromSignature('sponsor_unconditionally()'),
+          type: FunctionType.PRIVATE,
+          hideMsgSender: false,
+          isStatic: false,
+          args: [],
+          returnTypes: [],
+        },
+      ],
+      [],
+      [],
+      [],
+      this.paymentContract, // feePayer
+    );
+  }
+
+  getGasSettings(): GasSettings | undefined {
+    return;
+  }
+}

package/src/scripts/generate_protocol_contract_types.ts

@@ -0,0 +1,150 @@
+/**
+ * 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/builder/codegen';
+import {
+  type ContractArtifact,
+  type FunctionAbi,
+  FunctionType,
+  getAllFunctionAbis,
+  loadContractArtifact,
+} from '@aztec/stdlib/abi';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+const log = console.log;
+
+const noirContractsRoot = path.join(import.meta.dirname, '../../../../noir-projects/noir-contracts');
+const srcPath = path.join(noirContractsRoot, 'target');
+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,
+    returnTypes: abi.returnTypes,
+    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}',
+  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/protocol-contracts';
+import { FunctionType } from '@aztec/stdlib/abi';
+
+import type { ContractArtifact } from '../../api/abi.js';
+import { PublicKeys } from '../../api/keys.js';
+import type { AztecAddressLike, EthAddressLike, FieldLike, FunctionSelectorLike, 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);
+  }
+
+  public static at(wallet: Wallet): ${contractName} {
+    return new ${contractName}(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(noirContractsRoot, '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/utils/abi_types.ts

@@ -1,5 +1,5 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
 import type { EventSelector, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';