@aztec/aztec.js 0.1.0-alpha26 → 0.1.0-alpha28

package/src/contract/contract.ts

@@ -1,21 +1,8 @@
-import { ContractAbi, FunctionAbi, generateFunctionSelector } from '@aztec/foundation/abi';
+import { ContractAbi } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { DeployedContract } from '@aztec/types';
 
 import { Wallet } from '../aztec_rpc_client/wallet.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: Buffer;
-};
+import { ContractBase } from './contract_base.js';
 
 /**
  * The Contract class represents a contract and provides utility methods for interacting with it.
@@ -24,58 +11,18 @@ export type ContractMethod = ((...args: any[]) => ContractFunctionInteraction) &
  * to attach the contract instance to a deployed contract on-chain through the AztecRPCClient, which facilitates
  * interaction with Aztec's privacy protocol.
  */
-export class Contract {
-  /**
-   * An object containing contract methods mapped to their respective names.
-   */
-  public methods: { [name: string]: ContractMethod } = {};
-
-  constructor(
-    /**
-     * The deployed contract's address.
-     */
-    public readonly address: AztecAddress,
-    /**
-     * The Application Binary Interface for the contract.
-     */
-    public readonly abi: ContractAbi,
-    /**
-     * The wallet.
-     */
-    protected wallet: Wallet,
-  ) {
-    abi.functions.forEach((f: FunctionAbi) => {
-      const interactionFunction = (...args: any[]) => {
-        return new ContractFunctionInteraction(this.wallet, this.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 generateFunctionSelector(f.name, f.parameters);
-        },
-      });
-    });
-  }
-
+export class Contract extends ContractBase {
   /**
-   * Attach the current contract instance to a portal contract and optionally add its dependencies.
-   * The function will return a promise that resolves when all contracts have been added to the AztecRPCClient.
-   * This is useful when you need to interact with a deployed contract that has multiple nested contracts.
-   *
-   * @param portalContract - The Ethereum address of the portal contract.
-   * @param dependencies - An optional array of additional DeployedContract instances to be attached.
-   * @returns A promise that resolves when all contracts are successfully added to the AztecRPCClient.
+   * Creates a contract instance.
+   * @param address - The deployed contract's address.
+   * @param abi - The Application Binary Interface for the contract.
+   * @param wallet - The wallet to use when interacting with the contract.
+   * @returns A promise that resolves to a new Contract instance.
    */
-  attach(portalContract: EthAddress, dependencies: DeployedContract[] = []) {
-    const deployedContract: DeployedContract = {
-      abi: this.abi,
-      address: this.address,
-      portalContract,
-    };
-    return this.wallet.addContracts([deployedContract, ...dependencies]);
+  public static async create(address: AztecAddress, abi: ContractAbi, wallet: Wallet): Promise<Contract> {
+    if (!(await wallet.isContractDeployed(address))) {
+      throw new Error('Contract ' + address.toString() + ' is not deployed');
+    }
+    return new Contract(address, abi, wallet);
   }
 }

package/src/contract/contract_base.ts

@@ -0,0 +1,77 @@
+import { ContractAbi, FunctionAbi, generateFunctionSelector } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { DeployedContract } from '@aztec/types';
+
+import { Wallet } from '../aztec_rpc_client/wallet.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: Buffer;
+};
+
+/**
+ * Abstract implementation of a contract extended by the Contract class and generated contract types.
+ */
+export abstract class ContractBase {
+  /**
+   * An object containing contract methods mapped to their respective names.
+   */
+  public methods: { [name: string]: ContractMethod } = {};
+
+  protected constructor(
+    /**
+     * The deployed contract's address.
+     */
+    public readonly address: AztecAddress,
+    /**
+     * The Application Binary Interface for the contract.
+     */
+    public readonly abi: ContractAbi,
+    /**
+     * The wallet.
+     */
+    protected wallet: Wallet,
+  ) {
+    abi.functions.forEach((f: FunctionAbi) => {
+      const interactionFunction = (...args: any[]) => {
+        return new ContractFunctionInteraction(this.wallet, this.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 generateFunctionSelector(f.name, f.parameters);
+        },
+      });
+    });
+  }
+
+  /**
+   * Attach the current contract instance to a portal contract and optionally add its dependencies.
+   * The function will return a promise that resolves when all contracts have been added to the AztecRPCClient.
+   * This is useful when you need to interact with a deployed contract that has multiple nested contracts.
+   *
+   * @param portalContract - The Ethereum address of the portal contract.
+   * @param dependencies - An optional array of additional DeployedContract instances to be attached.
+   * @returns A promise that resolves when all contracts are successfully added to the AztecRPCClient.
+   */
+  public attach(portalContract: EthAddress, dependencies: DeployedContract[] = []) {
+    const deployedContract: DeployedContract = {
+      abi: this.abi,
+      address: this.address,
+      portalContract,
+    };
+    return this.wallet.addContracts([deployedContract, ...dependencies]);
+  }
+}

package/src/contract/contract_function_interaction.ts

@@ -1,5 +1,5 @@
 import { AztecAddress, Fr, FunctionData, TxContext } from '@aztec/circuits.js';
-import { FunctionAbi, FunctionType, encodeArguments, generateFunctionSelector } from '@aztec/foundation/abi';
+import { FunctionAbi, FunctionType, encodeArguments } from '@aztec/foundation/abi';
 import { ExecutionRequest, Tx, TxExecutionRequest } from '@aztec/types';
 
 import { Wallet } from '../aztec_rpc_client/wallet.js';
@@ -44,7 +44,11 @@ export class ContractFunctionInteraction {
     protected contractAddress: AztecAddress,
     protected functionDao: FunctionAbi,
     protected args: any[],
-  ) {}
+  ) {
+    if (args.some(arg => arg === undefined || arg === null)) {
+      throw new Error('All function interaction arguments must be defined and not null. Received: ' + args);
+    }
+  }
 
   /**
    * Create an Aztec transaction instance by combining the transaction request and its signature.
@@ -80,19 +84,23 @@ export class ContractFunctionInteraction {
     return this.tx;
   }
 
+  /**
+   * 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.
+   */
+  public request(options: SendMethodOptions = {}): ExecutionRequest {
+    return this.getExecutionRequest(this.contractAddress, options.origin);
+  }
+
   protected getExecutionRequest(to: AztecAddress, from?: AztecAddress): ExecutionRequest {
     const flatArgs = encodeArguments(this.functionDao, this.args);
     from = from ?? this.wallet.getAddress();
 
-    const functionData = new FunctionData(
-      generateFunctionSelector(this.functionDao.name, this.functionDao.parameters),
-      this.functionDao.functionType === FunctionType.SECRET,
-      this.functionDao.name === 'constructor',
-    );
-
     return {
       args: flatArgs,
-      functionData,
+      functionData: FunctionData.fromAbi(this.functionDao),
       to,
       from,
     };

package/src/contract/index.ts

@@ -1,3 +1,4 @@
 export * from './contract.js';
 export * from './contract_function_interaction.js';
 export * from './sent_tx.js';
+export * from './contract_base.js';

package/src/contract/sent_tx.ts

@@ -6,7 +6,7 @@ import { AztecRPC, TxHash, TxReceipt, TxStatus } from '@aztec/types';
  * its hash, receipt, and mining status.
  */
 export class SentTx {
-  constructor(private arc: AztecRPC, private txHashPromise: Promise<TxHash>) {}
+  constructor(protected arc: AztecRPC, protected txHashPromise: Promise<TxHash>) {}
 
   /**
    * Retrieves the transaction hash of the SentTx instance.
@@ -30,6 +30,19 @@ export class SentTx {
     return await this.arc.getTxReceipt(txHash);
   }
 
+  /**
+   * Awaits for a tx to be mined and returns the receipt. Throws if tx is not mined.
+   * @param timeout - The maximum time (in seconds) to wait for the transaction to be mined. A value of 0 means no timeout.
+   * @param interval - The time interval (in seconds) between retries to fetch the transaction receipt.
+   * @returns The transaction receipt.
+   */
+  public async wait(timeout = 0, interval = 1): Promise<TxReceipt> {
+    const receipt = await this.waitForReceipt(timeout, interval);
+    if (receipt.status !== TxStatus.MINED)
+      throw new Error(`Transaction ${await this.getTxHash()} was ${receipt.status}`);
+    return receipt;
+  }
+
   /**
    * Checks whether the transaction is mined or not within the specified timeout and retry interval.
    * Resolves to true if the transaction status is 'MINED', false otherwise.
@@ -40,8 +53,13 @@ export class SentTx {
    * @returns A Promise that resolves to a boolean indicating if the transaction is mined or not.
    */
   public async isMined(timeout = 0, interval = 1): Promise<boolean> {
+    const receipt = await this.waitForReceipt(timeout, interval);
+    return receipt.status === TxStatus.MINED;
+  }
+
+  protected async waitForReceipt(timeout = 0, interval = 1): Promise<TxReceipt> {
     const txHash = await this.getTxHash();
-    const receipt = await retryUntil(
+    return await retryUntil(
       async () => {
         const txReceipt = await this.arc.getTxReceipt(txHash);
         return txReceipt.status != TxStatus.PENDING ? txReceipt : undefined;
@@ -50,6 +68,5 @@ export class SentTx {
       timeout,
       interval,
     );
-    return receipt.status === TxStatus.MINED;
   }
 }

package/src/contract_deployer/contract_deployer.test.ts

@@ -2,7 +2,6 @@ import { AztecAddress, EthAddress, Fr, Point } from '@aztec/circuits.js';
 import { ContractAbi, FunctionType } from '@aztec/foundation/abi';
 import { AztecRPC, PublicKey, Tx, TxHash, TxReceipt } from '@aztec/types';
 
-import { randomBytes } from 'crypto';
 import { MockProxy, mock } from 'jest-mock-extended';
 
 import { ContractDeployer } from './contract_deployer.js';
@@ -16,6 +15,7 @@ describe.skip('Contract Deployer', () => {
       {
         name: 'constructor',
         functionType: FunctionType.SECRET,
+        isInternal: false,
         parameters: [],
         returnTypes: [],
         bytecode: '0af',
@@ -24,7 +24,7 @@ describe.skip('Contract Deployer', () => {
   };
 
   const publicKey: PublicKey = Point.random();
-  const portalContract = new EthAddress(randomBytes(EthAddress.SIZE_IN_BYTES));
+  const portalContract = EthAddress.random();
   const contractAddressSalt = Fr.random();
   const account = AztecAddress.random();
   const args = [12, 345n];

package/src/contract_deployer/contract_deployer.ts

@@ -6,9 +6,9 @@ import { DeployMethod } from './deploy_method.js';
 
 /**
  * A class for deploying contract.
+ * @remarks Keeping this around even though we have noir contract types because it can be useful for non-TS users.
  */
 export class ContractDeployer {
-  // TODO: remove this?
   constructor(private abi: ContractAbi, private arc: AztecRPC, private publicKey?: PublicKey) {}
 
   /**

package/src/contract_deployer/deploy_method.ts

@@ -149,10 +149,10 @@ export class DeployMethod extends ContractFunctionInteraction {
    * @param withWallet - The wallet to provide to the contract abstraction
    * @returns - The generated contract abstraction.
    */
-  public getContract(withWallet: Wallet) {
+  public async getContract(withWallet: Wallet) {
     if (!this.completeContractAddress) {
       throw new Error(`Cannot get a contract instance for a contract not yet deployed`);
     }
-    return new Contract(this.completeContractAddress, this.abi, withWallet);
+    return await Contract.create(this.completeContractAddress, this.abi, withWallet);
   }
 }

package/src/index.ts

@@ -9,4 +9,22 @@ export * from './contract_deployer/deploy_method.js';
 // export * from '@aztec/aztec-rpc';
 
 export { AztecAddress, EthAddress, Point, Fr } from '@aztec/circuits.js';
-export { AztecRPC } from '@aztec/types';
+export {
+  AztecRPC,
+  ContractData,
+  ContractDeploymentTx,
+  ContractPublicData,
+  DeployedContract,
+  ExecutionRequest,
+  L2BlockL2Logs,
+  NodeInfo,
+  PackedArguments,
+  PublicKey,
+  PrivateKey,
+  Tx,
+  TxExecutionRequest,
+  TxHash,
+  TxReceipt,
+  TxStatus,
+  emptyExecutionRequest,
+} from '@aztec/types';

package/src/utils/account.ts

@@ -1,7 +1,6 @@
-import { Fr, getContractDeploymentInfo } from '@aztec/circuits.js';
+import { Fr, PrivateKey, getContractDeploymentInfo } from '@aztec/circuits.js';
 import { Schnorr } from '@aztec/circuits.js/barretenberg';
 import { ContractAbi } from '@aztec/foundation/abi';
-import { randomBytes } from '@aztec/foundation/crypto';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AztecRPC, TxStatus } from '@aztec/types';
 
@@ -15,7 +14,7 @@ import { AccountCollection, ContractDeployer, SingleKeyAccountContract, generate
 export async function createAccounts(
   aztecRpcClient: AztecRPC,
   accountContractAbi: ContractAbi,
-  privateKey?: Buffer,
+  privateKey?: PrivateKey,
   salt = Fr.random(),
   numberOfAccounts = 1,
   logger = createDebugLogger('aztec:aztec.js:accounts'),
@@ -24,7 +23,7 @@ export async function createAccounts(
 
   for (let i = 0; i < numberOfAccounts; ++i) {
     // TODO(#662): Let the aztec rpc server generate the keypair rather than hardcoding the private key
-    const privKey = i == 0 && privateKey ? privateKey : randomBytes(32);
+    const privKey = i == 0 && privateKey ? privateKey : PrivateKey.random();
     const publicKey = await generatePublicKey(privKey);
     const deploymentInfo = await getContractDeploymentInfo(accountContractAbi, [], salt, publicKey);
     await aztecRpcClient.addAccount(privKey, deploymentInfo.address, deploymentInfo.partialAddress);
@@ -59,7 +58,7 @@ export async function createAccounts(
 export async function getAccountWallet(
   aztecRpcClient: AztecRPC,
   accountContractAbi: ContractAbi,
-  privateKey: Buffer,
+  privateKey: PrivateKey,
   salt: Fr,
 ) {
   const accountCollection = new AccountCollection();

package/src/utils/pub_key.ts

@@ -1,13 +1,12 @@
+import { PrivateKey, PublicKey } from '@aztec/circuits.js';
 import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 
-import { Point } from '../index.js';
-
 /**
  * Method for generating a public grumpkin key from a private key.
  * @param privateKey - The private key.
  * @returns The generated public key.
  */
-export async function generatePublicKey(privateKey: Buffer): Promise<Point> {
+export async function generatePublicKey(privateKey: PrivateKey): Promise<PublicKey> {
   const grumpkin = await Grumpkin.new();
-  return Point.fromBuffer(grumpkin.mul(grumpkin.generator(), privateKey));
+  return grumpkin.mul(grumpkin.generator(), privateKey);
 }

package/tsconfig.dest.json

@@ -0,0 +1,17 @@
+{
+  "extends": ".",
+  "references": [
+    {
+      "path": "../circuits.js/tsconfig.dest.json"
+    },
+    {
+      "path": "../foundation/tsconfig.dest.json"
+    },
+    {
+      "path": "../types/tsconfig.dest.json"
+    }
+  ],
+  "exclude": [
+    "src/**/*.test.ts"
+  ]
+}

package/webpack.config.js

@@ -0,0 +1,74 @@
+// import CopyWebpackPlugin from 'copy-webpack-plugin';
+import { createRequire } from 'module';
+import { dirname, resolve } from 'path';
+import path from 'path';
+import ResolveTypeScriptPlugin from 'resolve-typescript-plugin';
+import { fileURLToPath } from 'url';
+import webpack from 'webpack';
+
+const require = createRequire(import.meta.url);
+
+export default {
+  target: 'web',
+  mode: 'production',
+  devtool: false,
+  entry: {
+    main: './src/index.ts',
+  },
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: [
+          {
+            loader: 'ts-loader',
+            options: {
+              configFile: 'tsconfig.dest.json',
+            },
+          },
+        ],
+      },
+    ],
+  },
+  output: {
+    path: resolve(dirname(fileURLToPath(import.meta.url)), './dest'),
+    filename: 'main.js',
+    library: {
+      type: 'module',
+    },
+    chunkFormat: 'module',
+  },
+  experiments: {
+    outputModule: true,
+  },
+  plugins: [
+    new webpack.DefinePlugin({
+      'process.env': {
+        NODE_ENV: JSON.stringify('production'),
+      },
+    }),
+    new webpack.ProvidePlugin({ Buffer: ['buffer', 'Buffer'] }),
+  ],
+  resolve: {
+    plugins: [new ResolveTypeScriptPlugin()],
+    alias: {
+      // All node specific code, wherever it's located, should be imported as below.
+      // Provides a clean and simple way to always strip out the node code for the web build.
+      './node/index.js': false,
+    },
+    fallback: {
+      crypto: false,
+      os: false,
+      fs: false,
+      path: false,
+      url: false,
+      worker_threads: false,
+      events: require.resolve('events/'),
+      buffer: require.resolve('buffer/'),
+      util: require.resolve('util/'),
+      stream: require.resolve('stream-browserify'),
+      string_decoder: require.resolve('string_decoder/'),
+      tty: require.resolve('tty-browserify'),
+    },
+  },
+};

package/dest/abis/schnorr_account_contract.json

@@ -1,96 +0,0 @@
-{
-    "name": "SchnorrAccount",
-    "functions": [
-        {
-            "name": "constructor",
-            "functionType": "secret",
-            "parameters": [],
-            "returnTypes": []
-        },
-        {
-            "name": "entrypoint",
-            "functionType": "secret",
-            "parameters": [
-                {
-                    "name": "payload",
-                    "type": {
-                        "kind": "struct",
-                        "fields": [
-                            {
-                                "name": "flattened_args_hashes",
-                                "type": {
-                                    "kind": "array",
-                                    "length": 2,
-                                    "type": {
-                                        "kind": "field"
-                                    }
-                                }
-                            },
-                            {
-                                "name": "flattened_selectors",
-                                "type": {
-                                    "kind": "array",
-                                    "length": 2,
-                                    "type": {
-                                        "kind": "field"
-                                    }
-                                }
-                            },
-                            {
-                                "name": "flattened_targets",
-                                "type": {
-                                    "kind": "array",
-                                    "length": 2,
-                                    "type": {
-                                        "kind": "field"
-                                    }
-                                }
-                            },
-                            {
-                                "name": "nonce",
-                                "type": {
-                                    "kind": "field"
-                                }
-                            }
-                        ]
-                    },
-                    "visibility": "public"
-                },
-                {
-                    "name": "owner",
-                    "type": {
-                        "kind": "array",
-                        "length": 64,
-                        "type": {
-                            "kind": "integer",
-                            "sign": "unsigned",
-                            "width": 8
-                        }
-                    },
-                    "visibility": "public"
-                },
-                {
-                    "name": "signature",
-                    "type": {
-                        "kind": "array",
-                        "length": 64,
-                        "type": {
-                            "kind": "integer",
-                            "sign": "unsigned",
-                            "width": 8
-                        }
-                    },
-                    "visibility": "public"
-                },
-                {
-                    "name": "partial_address",
-                    "type": {
-                        "kind": "field"
-                    },
-                    "visibility": "public"
-                }
-            ],
-            "returnTypes": []
-        }
-    ]
-}