@aztec/aztec.js 0.23.0 → 0.26.1

package/src/account_manager/index.ts

@@ -0,0 +1,188 @@
+import { CompleteAddress, GrumpkinPrivateKey, PXE } from '@aztec/circuit-types';
+import { EthAddress, PublicKey, getContractInstanceFromDeployParams } from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { AccountContract } from '../account/contract.js';
+import { Salt } from '../account/index.js';
+import { AccountInterface } from '../account/interface.js';
+import { DeployMethod } from '../contract/deploy_method.js';
+import { DefaultWaitOpts, WaitOpts } from '../contract/sent_tx.js';
+import { ContractDeployer } from '../deployment/contract_deployer.js';
+import { waitForAccountSynch } from '../utils/account.js';
+import { generatePublicKey } from '../utils/index.js';
+import { AccountWalletWithPrivateKey, SignerlessWallet } from '../wallet/index.js';
+import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
+
+/**
+ * Manages a user account. Provides methods for calculating the account's address, deploying the account contract,
+ * and creating and registering the user wallet in the PXE Service.
+ */
+export class AccountManager {
+  /** Deployment salt for the account contract. */
+  public readonly salt: Fr;
+
+  // TODO(@spalladino): Does it make sense to have both completeAddress and instance?
+  private completeAddress?: CompleteAddress;
+  private instance?: ContractInstanceWithAddress;
+  private encryptionPublicKey?: PublicKey;
+  // TODO(@spalladino): Update to the new deploy method and kill the legacy one.
+  private deployMethod?: DeployMethod;
+
+  constructor(
+    private pxe: PXE,
+    private encryptionPrivateKey: GrumpkinPrivateKey,
+    private accountContract: AccountContract,
+    salt?: Salt,
+  ) {
+    this.salt = salt ? new Fr(salt) : Fr.random();
+  }
+
+  protected getEncryptionPublicKey() {
+    if (!this.encryptionPublicKey) {
+      this.encryptionPublicKey = generatePublicKey(this.encryptionPrivateKey);
+    }
+    return this.encryptionPublicKey;
+  }
+
+  /**
+   * Returns the entrypoint for this account as defined by its account contract.
+   * @returns An entrypoint.
+   */
+  public async getAccount(): Promise<AccountInterface> {
+    const nodeInfo = await this.pxe.getNodeInfo();
+    const completeAddress = this.getCompleteAddress();
+    return this.accountContract.getInterface(completeAddress, nodeInfo);
+  }
+
+  /**
+   * Gets the calculated complete address associated with this account.
+   * Does not require the account to be deployed or registered.
+   * @returns The address, partial address, and encryption public key.
+   */
+  public getCompleteAddress(): CompleteAddress {
+    if (!this.completeAddress) {
+      const encryptionPublicKey = generatePublicKey(this.encryptionPrivateKey);
+      const instance = this.getInstance();
+      this.completeAddress = CompleteAddress.fromPublicKeyAndInstance(encryptionPublicKey, instance);
+    }
+    return this.completeAddress;
+  }
+
+  /**
+   * Returns the contract instance definition associated with this account.
+   * Does not require the account to be deployed or registered.
+   * @returns ContractInstance instance.
+   */
+  public getInstance(): ContractInstanceWithAddress {
+    if (!this.instance) {
+      const encryptionPublicKey = generatePublicKey(this.encryptionPrivateKey);
+      const portalAddress = EthAddress.ZERO;
+      this.instance = getContractInstanceFromDeployParams(
+        this.accountContract.getContractArtifact(),
+        this.accountContract.getDeploymentArgs(),
+        this.salt,
+        encryptionPublicKey,
+        portalAddress,
+      );
+    }
+    return this.instance;
+  }
+
+  /**
+   * Returns a Wallet instance associated with this account. Use it to create Contract
+   * instances to be interacted with from this account.
+   * @returns A Wallet instance.
+   */
+  public async getWallet(): Promise<AccountWalletWithPrivateKey> {
+    const entrypoint = await this.getAccount();
+    return new AccountWalletWithPrivateKey(this.pxe, entrypoint, this.encryptionPrivateKey, this.salt);
+  }
+
+  /**
+   * Registers this account in the PXE Service and returns the associated wallet. Registering
+   * the account on the PXE Service is required for managing private state associated with it.
+   * Use the returned wallet to create Contract instances to be interacted with from this account.
+   * @param opts - Options to wait for the account to be synched.
+   * @returns A Wallet instance.
+   */
+  public async register(opts: WaitOpts = DefaultWaitOpts): Promise<AccountWalletWithPrivateKey> {
+    await this.#register();
+    await this.pxe.addContracts([
+      {
+        artifact: this.accountContract.getContractArtifact(),
+        instance: this.getInstance(),
+      },
+    ]);
+
+    await waitForAccountSynch(this.pxe, this.getCompleteAddress(), opts);
+    return this.getWallet();
+  }
+
+  /**
+   * Returns the pre-populated deployment method to deploy the account contract that backs this account.
+   * Typically you will not need this method and can call `deploy` directly. Use this for having finer
+   * grained control on when to create, simulate, and send the deployment tx.
+   * @returns A DeployMethod instance that deploys this account contract.
+   */
+  public async getDeployMethod() {
+    if (!this.deployMethod) {
+      if (!this.salt) {
+        throw new Error(`Cannot deploy account contract without known salt.`);
+      }
+      await this.#register();
+      const encryptionPublicKey = this.getEncryptionPublicKey();
+      // We use a signerless wallet so we hit the account contract directly and it deploys itself.
+      // If we used getWallet, the deployment would get routed via the account contract entrypoint
+      // instead of directly hitting the initializer.
+      const deployWallet = new SignerlessWallet(this.pxe);
+      const deployer = new ContractDeployer(
+        this.accountContract.getContractArtifact(),
+        deployWallet,
+        encryptionPublicKey,
+      );
+      const args = this.accountContract.getDeploymentArgs();
+      this.deployMethod = deployer.deploy(...args);
+    }
+    return this.deployMethod;
+  }
+
+  /**
+   * Deploys the account contract that backs this account.
+   * Does not register the associated class nor publicly deploy the instance.
+   * Uses the salt provided in the constructor or a randomly generated one.
+   * Note that if the Account is constructed with an explicit complete address
+   * it is assumed that the account contract has already been deployed and this method will throw.
+   * Registers the account in the PXE Service before deploying the contract.
+   * @returns A SentTx object that can be waited to get the associated Wallet.
+   */
+  public async deploy(): Promise<DeployAccountSentTx> {
+    const deployMethod = await this.getDeployMethod();
+    const wallet = await this.getWallet();
+    const sentTx = deployMethod.send({
+      contractAddressSalt: this.salt,
+      skipClassRegistration: true,
+      skipPublicDeployment: true,
+    });
+    return new DeployAccountSentTx(wallet, sentTx.getTxHash());
+  }
+
+  /**
+   * Deploys the account contract that backs this account and awaits the tx to be mined.
+   * Uses the salt provided in the constructor or a randomly generated one.
+   * Note that if the Account is constructed with an explicit complete address
+   * it is assumed that the account contract has already been deployed and this method will throw.
+   * Registers the account in the PXE Service before deploying the contract.
+   * @param opts - Options to wait for the tx to be mined.
+   * @returns A Wallet instance.
+   */
+  public async waitDeploy(opts: WaitOpts = DefaultWaitOpts): Promise<AccountWalletWithPrivateKey> {
+    await this.deploy().then(tx => tx.wait(opts));
+    return this.getWallet();
+  }
+
+  async #register(): Promise<void> {
+    const completeAddress = this.getCompleteAddress();
+    await this.pxe.registerAccount(this.encryptionPrivateKey, completeAddress.partialAddress);
+  }
+}

package/src/api/README.md

@@ -0,0 +1,7 @@
+# API
+
+This provides a more modular api for importing parts of the library as needed.
+The root `index.js` just exposes everything, which can have consequences for startup times and optimizations.
+Here we can gradually build up a much more granular api to allow importing precisely what's needed.
+This should adopt the opposite philosophy to "export all my child exports".
+Every file should (usually) export one thing, and the file/directory structure should be reflected in package.json exports.

package/src/api/abi.ts

@@ -0,0 +1,3 @@
+export { ContractArtifact, FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';
+export { loadContractArtifact } from '@aztec/types/abi';
+export { NoirCompiledContract } from '@aztec/types/noir';

package/src/api/account.ts

@@ -0,0 +1,13 @@
+export {
+  AccountContract,
+  AccountInterface,
+  AuthWitnessProvider,
+  EntrypointInterface,
+  Salt,
+  Wallet,
+  FeeOptions,
+} from '../account/index.js';
+
+export { AccountManager } from '../account_manager/index.js';
+
+export { CompleteAddress } from '@aztec/circuit-types';

package/src/api/aztec_address.ts

@@ -0,0 +1 @@
+export { AztecAddress } from '@aztec/foundation/aztec-address';

package/src/api/deployment.ts

@@ -0,0 +1,3 @@
+export { registerContractClass } from '../deployment/register_class.js';
+export { broadcastPrivateFunction, broadcastUnconstrainedFunction } from '../deployment/broadcast_function.js';
+export { deployInstance } from '../deployment/deploy_instance.js';

package/src/api/eth_address.ts

@@ -0,0 +1 @@
+export { EthAddress } from '@aztec/foundation/eth-address';

package/src/api/ethereum.ts

@@ -0,0 +1,6 @@
+export {
+  deployL1Contract,
+  deployL1Contracts,
+  DeployL1Contracts,
+  L1ContractArtifactsForDeployment,
+} from '@aztec/ethereum';

package/src/api/fee.ts

@@ -0,0 +1,4 @@
+export type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+export { NativeFeePaymentMethod } from '../fee/native_fee_payment_method.js';
+export { PrivateFeePaymentMethod } from '../fee/private_fee_payment_method.js';
+export { PublicFeePaymentMethod } from '../fee/public_fee_payment_method.js';

package/src/api/fields.ts

@@ -0,0 +1 @@
+export { Point, Fr, Fq, GrumpkinScalar } from '@aztec/foundation/fields';

package/src/api/init.ts

@@ -0,0 +1,10 @@
+import { init } from '@aztec/foundation/crypto';
+
+/**
+ * This should only be needed to be called in CJS environments that don't have top level await.
+ * Initializes any asynchronous subsystems required to use the library.
+ * At time of writing, this is just our foundation crypto lib.
+ */
+export async function initAztecJs() {
+  await init();
+}

package/src/api/interfaces/pxe.ts

@@ -0,0 +1 @@
+export { PXE } from '@aztec/circuit-types/interfaces';

package/src/api/log_id.ts

@@ -0,0 +1 @@
+export { LogId } from '@aztec/circuit-types/log_id';

package/src/api/tx_hash.ts

@@ -0,0 +1 @@
+export { TxHash } from '@aztec/circuit-types/tx_hash';

package/src/api/wallet.ts

@@ -0,0 +1 @@
+export { AccountWallet, AccountWalletWithPrivateKey, SignerlessWallet, Wallet, getWallet } from '../wallet/index.js';

package/src/contract/base_contract_interaction.ts

@@ -0,0 +1,67 @@
+import { PXE, Tx, TxExecutionRequest } from '@aztec/circuit-types';
+
+import { FeeOptions } from '../account/interface.js';
+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;
+
+  /**
+   * The fee options for the transaction.
+   */
+  fee?: FeeOptions;
+};
+
+/**
+ * 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

@@ -0,0 +1,24 @@
+import { FunctionCall, TxExecutionRequest } from '@aztec/circuit-types';
+
+import { Wallet } from '../account/index.js';
+import { BaseContractInteraction, SendMethodOptions } 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.
+   * @param opts - An optional object containing additional configuration for the transaction.
+   * @returns A Promise that resolves to a transaction instance.
+   */
+  public async create(opts?: SendMethodOptions): Promise<TxExecutionRequest> {
+    if (!this.txRequest) {
+      this.txRequest = await this.wallet.createTxExecutionRequest(this.calls, opts?.fee);
+    }
+    return this.txRequest;
+  }
+}

package/src/contract/checker.ts

@@ -0,0 +1,117 @@
+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

@@ -0,0 +1,64 @@
+import { PublicKey } from '@aztec/circuit-types';
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Point } from '@aztec/foundation/fields';
+
+import { Wallet } from '../account/index.js';
+import { ContractBase } from './contract_base.js';
+import { DeployMethod } from './deploy_method.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 instance = await wallet.getContractInstance(address);
+    if (instance === undefined) {
+      throw new Error(`Contract instance at ${address.toString()} has not been registered in the wallet's PXE`);
+    }
+    return new Contract(instance, artifact, wallet);
+  }
+
+  /**
+   * 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.
+   * @param constructorName - The name of the constructor function to call.
+   */
+  public static deploy(wallet: Wallet, artifact: ContractArtifact, args: any[], constructorName?: string) {
+    const postDeployCtor = (address: AztecAddress, wallet: Wallet) => Contract.at(address, artifact, wallet);
+    return new DeployMethod(Point.ZERO, wallet, artifact, postDeployCtor, args, constructorName);
+  }
+
+  /**
+   * 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.
+   * @param constructorName - The name of the constructor function to call.
+   */
+  public static deployWithPublicKey(
+    publicKey: PublicKey,
+    wallet: Wallet,
+    artifact: ContractArtifact,
+    args: any[],
+    constructorName?: string,
+  ) {
+    const postDeployCtor = (address: AztecAddress, wallet: Wallet) => Contract.at(address, artifact, wallet);
+    return new DeployMethod(publicKey, wallet, artifact, postDeployCtor, args, constructorName);
+  }
+}

package/src/contract/contract_base.ts

@@ -0,0 +1,72 @@
+import { DeployedContract } from '@aztec/circuit-types';
+import { computePartialAddress } from '@aztec/circuits.js';
+import { ContractArtifact, FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { Wallet } from '../account/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 instance definition. */
+    public readonly instance: ContractInstanceWithAddress,
+    /** The Application Binary Interface for the contract. */
+    public readonly artifact: ContractArtifact,
+    /** The wallet used for interacting with this contract. */
+    protected wallet: Wallet,
+  ) {
+    artifact.functions.forEach((f: FunctionArtifact) => {
+      const interactionFunction = (...args: any[]) => {
+        return new ContractFunctionInteraction(this.wallet, this.instance.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.instance.address;
+  }
+
+  /** Partial address of the contract. */
+  public get partialAddress() {
+    return computePartialAddress(this.instance);
+  }
+
+  /**
+   * 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.instance, this.artifact, wallet) as this;
+  }
+}