@aztec/aztec.js 0.16.3 → 0.16.5

package/src/contract/base_contract_interaction.ts

@@ -1,61 +0,0 @@
-import { PXE, Tx, TxExecutionRequest } from '@aztec/types';
-
-import { SentTx } from './sent_tx.js';
-
-/**
- * Represents options for calling a (constrained) function in a contract.
- * Allows the user to specify the sender address and nonce for a transaction.
- */
-export type SendMethodOptions = {
-  /**
-   * Wether to skip the simulation of the public part of the transaction.
-   */
-  skipPublicSimulation?: boolean;
-};
-
-/**
- * Base class for an interaction with a contract, be it a deployment, a function call, or a batch.
- * Implements the sequence create/simulate/send.
- */
-export abstract class BaseContractInteraction {
-  protected tx?: Tx;
-  protected txRequest?: TxExecutionRequest;
-
-  constructor(protected pxe: PXE) {}
-
-  /**
-   * Create a transaction execution request ready to be simulated.
-   * @param options - An optional object containing additional configuration for the transaction.
-   * @returns A transaction execution request.
-   */
-  public abstract create(options?: SendMethodOptions): Promise<TxExecutionRequest>;
-
-  /**
-   * Simulates a transaction execution request and returns a tx object ready to be sent.
-   * @param options - optional arguments to be used in the creation of the transaction
-   * @returns The resulting transaction
-   */
-  public async simulate(options: SendMethodOptions = {}): Promise<Tx> {
-    const txRequest = this.txRequest ?? (await this.create(options));
-    this.tx = await this.pxe.simulateTx(txRequest, !options.skipPublicSimulation);
-    return this.tx;
-  }
-
-  /**
-   * Sends a transaction to the contract function with the specified options.
-   * This function throws an error if called on an unconstrained function.
-   * It creates and signs the transaction if necessary, and returns a SentTx instance,
-   * which can be used to track the transaction status, receipt, and events.
-   * @param options - An optional object containing 'from' property representing
-   * the AztecAddress of the sender. If not provided, the default address is used.
-   * @returns A SentTx instance for tracking the transaction status and information.
-   */
-  public send(options: SendMethodOptions = {}) {
-    const promise = (async () => {
-      const tx = this.tx ?? (await this.simulate(options));
-      return this.pxe.sendTx(tx);
-    })();
-
-    return new SentTx(this.pxe, promise);
-  }
-}

package/src/contract/batch_call.ts

@@ -1,23 +0,0 @@
-import { FunctionCall, TxExecutionRequest } from '@aztec/types';
-
-import { Wallet } from '../wallet/index.js';
-import { BaseContractInteraction } from './base_contract_interaction.js';
-
-/** A batch of function calls to be sent as a single transaction through a wallet. */
-export class BatchCall extends BaseContractInteraction {
-  constructor(protected wallet: Wallet, protected calls: FunctionCall[]) {
-    super(wallet);
-  }
-
-  /**
-   * Create a transaction execution request that represents this batch, encoded and authenticated by the
-   * user's wallet, ready to be simulated.
-   * @returns A Promise that resolves to a transaction instance.
-   */
-  public async create(): Promise<TxExecutionRequest> {
-    if (!this.txRequest) {
-      this.txRequest = await this.wallet.createTxExecutionRequest(this.calls);
-    }
-    return this.txRequest;
-  }
-}

package/src/contract/checker.ts

@@ -1,117 +0,0 @@
-import { ABIType, BasicType, ContractArtifact, StructType } from '@aztec/foundation/abi';
-
-/**
- * Represents a type derived from input type T with the 'kind' property removed.
- * Useful when checking attributes of a specific kind and validating their types.
- */
-type TypeWithoutKind<T> = Omit<{ [key in keyof T]: any }, 'kind'>;
-
-/**
- * Validates the given ContractArtifact object by checking its functions and their parameters.
- * Ensures that the ABI has at least one function, a constructor, valid bytecode, and correct parameter types.
- * Throws an error if any inconsistency is detected during the validation process.
- *
- * @param artifact - The ContractArtifact object to be validated.
- * @returns A boolean value indicating whether the artifact is valid or not.
- */
-export function abiChecker(artifact: ContractArtifact) {
-  if (!artifact.functions || artifact.functions.length === 0) {
-    throw new Error('artifact has no functions');
-  }
-
-  artifact.functions.forEach(func => {
-    if (!('name' in func && typeof func.name === 'string' && func.name.length > 0)) {
-      throw new Error('ABI function has no name');
-    }
-
-    // TODO: implement a better check for bytecode (right now only checks if it's > 0)
-    if (!('bytecode' in func && typeof func.bytecode === 'string' && func.bytecode.length > 0)) {
-      throw new Error('ABI function parameter has incorrect bytecode');
-    }
-
-    func.parameters.forEach(param => {
-      if (!param.type) {
-        throw new Error('ABI function parameter has no type');
-      }
-
-      abiParameterTypeChecker(param.type);
-    });
-  });
-
-  // TODO: implement a better check for constructor (right now only checks if it has it or not)
-  if (!artifact.functions.find(func => func.name === 'constructor')) {
-    throw new Error('ABI has no constructor');
-  }
-
-  return true;
-}
-
-/**
- * Validates the ABI function parameter's type by checking its kind and attributes.
- * Throws an error if the type has an unrecognized kind or incorrectly formed attributes.
- * Additionally, checks nested types for array and struct kinds.
- *
- * @param type - The ABIType object representing the type of the ABI function parameter.
- * @returns A boolean value indicating whether the type is valid or not.
- */
-function abiParameterTypeChecker(type: ABIType): boolean {
-  switch (type.kind) {
-    case 'field':
-    case 'boolean':
-      return checkAttributes(type, {});
-    case 'integer':
-      return checkAttributes(type, { sign: 'string', width: 'number' });
-    case 'string':
-      return checkAttributes(type, { length: 'number' });
-    case 'array':
-      return checkAttributes(type, { length: 'number', type: 'object' }) && abiParameterTypeChecker(type.type);
-    case 'struct':
-      return checkAttributes(type, { fields: 'object', path: 'string' }) && checkStruct(type);
-    default:
-      throw new Error('ABI function parameter has an unrecognized type');
-  }
-}
-
-/**
- * Check if the structure of the ABIType 'struct' is valid by ensuring field names are strings
- * and their type attribute passes the abiParameterTypeChecker. Returns true on successful validation,
- * otherwise throws an error providing insight into the incorrect formation in the struct.
- *
- * @param type - The StructType object containing an array of fields to validate.
- * @returns A boolean value indicating successful validation of the struct's fields.
- */
-function checkStruct(type: StructType) {
-  return type.fields.reduce((acc, field) => {
-    if (!('name' in field && typeof field.name === 'string')) {
-      throw new Error('ABI function parameter has an incorrectly formed struct');
-    }
-    return acc && abiParameterTypeChecker(field.type);
-  }, true);
-}
-
-/**
- * Check if a provided ABI type has the correct attributes and their associated types.
- * This function compares the given 'type' object's keys with the expected attribute types
- * specified in 'incompleteAttributes', as well as the required 'kind' property.
- * Throws an error if there are any unrecognized attributes or incorrect attribute types.
- *
- * @param type - The ABI type object to be checked for correct attributes.
- * @param incompleteAttributes - An object representing the expected attribute types without the 'kind' property.
- * @returns Returns true if the provided ABI type has the correct attributes and their associated types, otherwise throws an error.
- */
-function checkAttributes<T extends BasicType<string>>(type: T, incompleteAttributes: TypeWithoutKind<T>) {
-  const typeKeys = Object.keys(type);
-  const attributes = { ...incompleteAttributes, kind: 'string' };
-
-  if (typeKeys.length !== Object.keys(attributes).length) {
-    throw new Error(`Unrecognized attribute on type ${type.kind}`);
-  }
-
-  typeKeys.forEach(element => {
-    if (!(element in type && typeof (type as any)[element] === (attributes as any)[element])) {
-      throw new Error(`ABI function parameter has an incorrectly formed ${type.kind}`);
-    }
-  });
-
-  return true;
-}

package/src/contract/contract.ts

@@ -1,59 +0,0 @@
-import { ContractArtifact } from '@aztec/foundation/abi';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { Point } from '@aztec/foundation/fields';
-import { PublicKey } from '@aztec/types';
-
-import { DeployMethod } from '../contract_deployer/deploy_method.js';
-import { Wallet } from '../wallet/index.js';
-import { ContractBase } from './contract_base.js';
-
-/**
- * The Contract class represents a contract and provides utility methods for interacting with it.
- * It enables the creation of ContractFunctionInteraction instances for each function in the contract's ABI,
- * allowing users to call or send transactions to these functions. Additionally, the Contract class can be used
- * to attach the contract instance to a deployed contract on-chain through the PXE, which facilitates
- * interaction with Aztec's privacy protocol.
- */
-export class Contract extends ContractBase {
-  /**
-   * Creates a contract instance.
-   * @param address - The deployed contract's address.
-   * @param artifact - Build artifact of the contract.
-   * @param wallet - The wallet to use when interacting with the contract.
-   * @param portalContract - The portal contract address on L1, if any.
-   * @returns A promise that resolves to a new Contract instance.
-   */
-  public static async at(address: AztecAddress, artifact: ContractArtifact, wallet: Wallet): Promise<Contract> {
-    const extendedContractData = await wallet.getExtendedContractData(address);
-    if (extendedContractData === undefined) {
-      throw new Error('Contract ' + address.toString() + ' is not deployed');
-    }
-    return new Contract(
-      extendedContractData.getCompleteAddress(),
-      artifact,
-      wallet,
-      extendedContractData.contractData.portalContractAddress,
-    );
-  }
-
-  /**
-   * Creates a tx to deploy a new instance of a contract.
-   * @param wallet - The wallet for executing the deployment.
-   * @param artifact - Build artifact of the contract to deploy
-   * @param args - Arguments for the constructor.
-   */
-  public static deploy(wallet: Wallet, artifact: ContractArtifact, args: any[]) {
-    return new DeployMethod(Point.ZERO, wallet, artifact, args);
-  }
-
-  /**
-   * Creates a tx to deploy a new instance of a contract using the specified public key to derive the address.
-   * @param publicKey - Public key for deriving the address.
-   * @param wallet - The wallet for executing the deployment.
-   * @param artifact - Build artifact of the contract.
-   * @param args - Arguments for the constructor.
-   */
-  public static deployWithPublicKey(publicKey: PublicKey, wallet: Wallet, artifact: ContractArtifact, args: any[]) {
-    return new DeployMethod(publicKey, wallet, artifact, args);
-  }
-}

package/src/contract/contract_base.ts

@@ -1,70 +0,0 @@
-import { ContractArtifact, FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { CompleteAddress, DeployedContract } from '@aztec/types';
-
-import { Wallet } from '../wallet/index.js';
-import { ContractFunctionInteraction } from './contract_function_interaction.js';
-
-/**
- * Type representing a contract method that returns a ContractFunctionInteraction instance
- * and has a readonly 'selector' property of type Buffer. Takes any number of arguments.
- */
-export type ContractMethod = ((...args: any[]) => ContractFunctionInteraction) & {
-  /**
-   * The unique identifier for a contract function in bytecode.
-   */
-  readonly selector: FunctionSelector;
-};
-
-/**
- * Abstract implementation of a contract extended by the Contract class and generated contract types.
- */
-export class ContractBase implements DeployedContract {
-  /**
-   * An object containing contract methods mapped to their respective names.
-   */
-  public methods: { [name: string]: ContractMethod } = {};
-
-  protected constructor(
-    /** The deployed contract's complete address. */
-    public readonly completeAddress: CompleteAddress,
-    /** The Application Binary Interface for the contract. */
-    public readonly artifact: ContractArtifact,
-    /** The wallet used for interacting with this contract. */
-    protected wallet: Wallet,
-    /** The portal contract address on L1, if any. */
-    public readonly portalContract: EthAddress,
-  ) {
-    artifact.functions.forEach((f: FunctionArtifact) => {
-      const interactionFunction = (...args: any[]) => {
-        return new ContractFunctionInteraction(this.wallet, this.completeAddress.address!, f, args);
-      };
-
-      this.methods[f.name] = Object.assign(interactionFunction, {
-        /**
-         * A getter for users to fetch the function selector.
-         * @returns Selector of the function.
-         */
-        get selector() {
-          return FunctionSelector.fromNameAndParameters(f.name, f.parameters);
-        },
-      });
-    });
-  }
-
-  /**
-   * Address of the contract.
-   */
-  public get address() {
-    return this.completeAddress.address;
-  }
-
-  /**
-   * Creates a new instance of the contract wrapper attached to a different wallet.
-   * @param wallet - Wallet to use for sending txs.
-   * @returns A new contract instance.
-   */
-  public withWallet(wallet: Wallet): this {
-    return new ContractBase(this.completeAddress, this.artifact, wallet, this.portalContract) as this;
-  }
-}

package/src/contract/contract_function_interaction.ts

@@ -1,80 +0,0 @@
-import { AztecAddress, FunctionData } from '@aztec/circuits.js';
-import { FunctionAbi, FunctionType, encodeArguments } from '@aztec/foundation/abi';
-import { FunctionCall, TxExecutionRequest } from '@aztec/types';
-
-import { Wallet } from '../wallet/index.js';
-import { BaseContractInteraction, SendMethodOptions } from './base_contract_interaction.js';
-
-export { SendMethodOptions };
-
-/**
- * Represents the options for a view method in a contract function interaction.
- * Allows specifying the address from which the view method should be called.
- */
-export type ViewMethodOptions = {
-  /**
-   * The sender's Aztec address.
-   */
-  from?: AztecAddress;
-};
-
-/**
- * This is the class that is returned when calling e.g. `contract.methods.myMethod(arg0, arg1)`.
- * It contains available interactions one can call on a method, including view.
- */
-export class ContractFunctionInteraction extends BaseContractInteraction {
-  constructor(
-    protected wallet: Wallet,
-    protected contractAddress: AztecAddress,
-    protected functionDao: FunctionAbi,
-    protected args: any[],
-  ) {
-    super(wallet);
-    if (args.some(arg => arg === undefined || arg === null)) {
-      throw new Error('All function interaction arguments must be defined and not null. Received: ' + args);
-    }
-  }
-
-  /**
-   * Create a transaction execution request that represents this call, encoded and authenticated by the
-   * user's wallet, ready to be simulated.
-   * @returns A Promise that resolves to a transaction instance.
-   */
-  public async create(): Promise<TxExecutionRequest> {
-    if (this.functionDao.functionType === FunctionType.UNCONSTRAINED) {
-      throw new Error("Can't call `create` on an unconstrained function.");
-    }
-    if (!this.txRequest) {
-      this.txRequest = await this.wallet.createTxExecutionRequest([this.request()]);
-    }
-    return this.txRequest;
-  }
-
-  /**
-   * Returns an execution request that represents this operation. Useful as a building
-   * block for constructing batch requests.
-   * @param options - An optional object containing additional configuration for the transaction.
-   * @returns An execution request wrapped in promise.
-   */
-  public request(): FunctionCall {
-    const args = encodeArguments(this.functionDao, this.args);
-    const functionData = FunctionData.fromAbi(this.functionDao);
-    return { args, functionData, to: this.contractAddress };
-  }
-
-  /**
-   * Execute a view (read-only) transaction on an unconstrained function.
-   * This method is used to call functions that do not modify the contract state and only return data.
-   * Throws an error if called on a non-unconstrained function.
-   * @param options - An optional object containing additional configuration for the transaction.
-   * @returns The result of the view transaction as returned by the contract function.
-   */
-  public view(options: ViewMethodOptions = {}) {
-    if (this.functionDao.functionType !== FunctionType.UNCONSTRAINED) {
-      throw new Error('Can only call `view` on an unconstrained function.');
-    }
-
-    const { from } = options;
-    return this.wallet.viewTx(this.functionDao.name, this.args, this.contractAddress, from);
-  }
-}

package/src/contract/index.ts

@@ -1,42 +0,0 @@
-/**
- * The `contract` module provides utilities for deploying and interacting with contracts, based on a
- * `Wallet` instance and a compiled artifact. Refer to the {@link account} module for how to obtain a valid
- * `Wallet` instance, and to the {@link https://docs.aztec.network/dev_docs/contracts/compiling | Compiling contracts}
- * section of the documentation for how to generate an artifact out of your Noir source code.
- *
- * The {@link Contract} class is the main class in this module, and provides static methods for deploying
- * a contract or interacting with an already deployed one. The `methods` property of the contract instance
- * provides access to private, public, and view methods, that can be invoked in a transaction via `send()`,
- * or can be queried via `view()`.
- *
- * ```ts
- * const contract = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send().deployed();
- * console.log(`Contract deployed at ${contract.address}`);
- * ```
- *
- * ```ts
- * const contract = await Contract.at(address, MyContractArtifact, wallet);
- * await contract.methods.mint(1000, owner).send().wait();
- * console.log(`Total supply is now ${await contract.methods.totalSupply().view()}`);
- * ```
- *
- * The result of calling a method in a contract instance, such as `contract.methods.mint(1000, owner)`
- * in the example, is a {@link ContractFunctionInteraction} instance. Usually this will be just sent as
- * a transaction to the network via the `send` method, but you can also `simulate` it without sending,
- * or obtaining the `request` for aggregating into a {@link BatchCall}.
- *
- * The result of `send`ing a transaction is a {@link SentTx} object, from which you can get the
- * transaction hash, or simply `wait` until the transaction is mined and the local PXE Service
- * has synchronized its changes.
- *
- * @remarks If you are using typescript, consider using the
- * {@link https://docs.aztec.network/dev_docs/contracts/compiling#typescript-interfaces | autogenerated type-safe interfaces}
- * for interacting with your contracts.
- *
- * @packageDocumentation
- */
-export * from './contract.js';
-export * from './contract_function_interaction.js';
-export { SentTx, WaitOpts } from './sent_tx.js';
-export * from './contract_base.js';
-export * from './batch_call.js';

package/src/contract/sent_tx.ts

@@ -1,137 +0,0 @@
-import { FieldsOf } from '@aztec/circuits.js';
-import { retryUntil } from '@aztec/foundation/retry';
-import { ExtendedNote, GetUnencryptedLogsResponse, PXE, TxHash, TxReceipt, TxStatus } from '@aztec/types';
-
-import every from 'lodash.every';
-
-/** Options related to waiting for a tx. */
-export type WaitOpts = {
-  /** The maximum time (in seconds) to wait for the transaction to be mined. Defaults to 60. */
-  timeout?: number;
-  /** The time interval (in seconds) between retries to fetch the transaction receipt. Defaults to 1. */
-  interval?: number;
-  /**
-   * Whether to wait for the PXE Service to sync all notes up to the block in which this tx was mined.
-   * If false, then any queries that depend on state set by this transaction may return stale data. Defaults to true.
-   **/
-  waitForNotesSync?: boolean;
-  /** Whether to include information useful for debugging/testing in the receipt. */
-  debug?: boolean;
-};
-
-export const DefaultWaitOpts: WaitOpts = {
-  timeout: 60,
-  interval: 1,
-  waitForNotesSync: true,
-  debug: false,
-};
-
-/**
- * The SentTx class represents a sent transaction through the PXE, providing methods to fetch
- * its hash, receipt, and mining status.
- */
-export class SentTx {
-  constructor(protected pxe: PXE, protected txHashPromise: Promise<TxHash>) {}
-
-  /**
-   * Retrieves the transaction hash of the SentTx instance.
-   * The function internally awaits for the 'txHashPromise' to resolve, and then returns the resolved transaction hash.
-   *
-   * @returns A promise that resolves to the transaction hash of the SentTx instance.
-   */
-  public async getTxHash() {
-    return await this.txHashPromise;
-  }
-
-  /**
-   * Retrieve the transaction receipt associated with the current SentTx instance.
-   * The function fetches the transaction hash using 'getTxHash' and then queries
-   * the PXE to get the corresponding transaction receipt.
-   *
-   * @returns A promise that resolves to a TxReceipt object representing the fetched transaction receipt.
-   */
-  public async getReceipt(): Promise<TxReceipt> {
-    const txHash = await this.getTxHash();
-    return await this.pxe.getTxReceipt(txHash);
-  }
-
-  /**
-   * Awaits for a tx to be mined and returns the receipt. Throws if tx is not mined.
-   * @param opts - Options for configuring the waiting for the tx to be mined.
-   * @returns The transaction receipt.
-   */
-  public async wait(opts?: WaitOpts): Promise<FieldsOf<TxReceipt>> {
-    if (opts?.debug && opts.waitForNotesSync === false) {
-      throw new Error('Cannot set getNotes to true if waitForNotesSync is false');
-    }
-    const receipt = await this.waitForReceipt(opts);
-    if (receipt.status !== TxStatus.MINED) {
-      throw new Error(`Transaction ${await this.getTxHash()} was ${receipt.status}`);
-    }
-    if (opts?.debug) {
-      const txHash = await this.getTxHash();
-      const tx = (await this.pxe.getTx(txHash))!;
-      const visibleNotes = await this.pxe.getNotes({ txHash });
-      receipt.debugInfo = {
-        newCommitments: tx.newCommitments,
-        newNullifiers: tx.newNullifiers,
-        newPublicDataWrites: tx.newPublicDataWrites,
-        newL2ToL1Msgs: tx.newL2ToL1Msgs,
-        newContracts: tx.newContracts,
-        newContractData: tx.newContractData,
-        visibleNotes,
-      };
-    }
-    return receipt;
-  }
-
-  /**
-   * Gets unencrypted logs emitted by this tx.
-   * @remarks This function will wait for the tx to be mined if it hasn't been already.
-   * @returns The requested logs.
-   */
-  public async getUnencryptedLogs(): Promise<GetUnencryptedLogsResponse> {
-    await this.wait();
-    return this.pxe.getUnencryptedLogs({ txHash: await this.getTxHash() });
-  }
-
-  /**
-   * Get notes of accounts registered in the provided PXE/Wallet created in this tx.
-   * @remarks This function will wait for the tx to be mined if it hasn't been already.
-   * @returns The requested notes.
-   */
-  public async getVisibleNotes(): Promise<ExtendedNote[]> {
-    await this.wait();
-    return this.pxe.getNotes({ txHash: await this.getTxHash() });
-  }
-
-  protected async waitForReceipt(opts?: WaitOpts): Promise<TxReceipt> {
-    const txHash = await this.getTxHash();
-    return await retryUntil(
-      async () => {
-        const txReceipt = await this.pxe.getTxReceipt(txHash);
-        // If receipt is not yet available, try again
-        if (txReceipt.status === TxStatus.PENDING) {
-          return undefined;
-        }
-        // If the tx was dropped, return it
-        if (txReceipt.status === TxStatus.DROPPED) {
-          return txReceipt;
-        }
-        // If we don't care about waiting for notes to be synced, return the receipt
-        const waitForNotesSync = opts?.waitForNotesSync ?? DefaultWaitOpts.waitForNotesSync;
-        if (!waitForNotesSync) {
-          return txReceipt;
-        }
-        // Check if all sync blocks on the PXE Service are greater or equal than the block in which the tx was mined
-        const { blocks, notes } = await this.pxe.getSyncStatus();
-        const targetBlock = txReceipt.blockNumber!;
-        const areNotesSynced = blocks >= targetBlock && every(notes, block => block >= targetBlock);
-        return areNotesSynced ? txReceipt : undefined;
-      },
-      'isMined',
-      opts?.timeout ?? DefaultWaitOpts.timeout,
-      opts?.interval ?? DefaultWaitOpts.interval,
-    );
-  }
-}

package/src/contract_deployer/contract_deployer.ts

@@ -1,26 +0,0 @@
-import { ContractArtifact } from '@aztec/foundation/abi';
-import { Point } from '@aztec/foundation/fields';
-import { PXE, PublicKey } from '@aztec/types';
-
-import { DeployMethod } from './deploy_method.js';
-
-/**
- * A class for deploying contract.
- * @remarks Keeping this around even though we have Aztec.nr contract types because it can be useful for non-TS users.
- */
-export class ContractDeployer {
-  constructor(private artifact: ContractArtifact, private pxe: PXE, private publicKey?: PublicKey) {}
-
-  /**
-   * Deploy a contract using the provided ABI and constructor arguments.
-   * This function creates a new DeployMethod instance that can be used to send deployment transactions
-   * and query deployment status. The method accepts any number of constructor arguments, which will
-   * be passed to the contract's constructor during deployment.
-   *
-   * @param args - The constructor arguments for the contract being deployed.
-   * @returns A DeployMethod instance configured with the ABI, PXE, and constructor arguments.
-   */
-  public deploy(...args: any[]) {
-    return new DeployMethod(this.publicKey ?? Point.ZERO, this.pxe, this.artifact, args);
-  }
-}