@aztec/aztec.js 0.1.0-alpha13

package/src/contract/sent_tx.ts

@@ -0,0 +1,55 @@
+import { AztecRPC, TxReceipt, TxHash, TxStatus } from '@aztec/aztec-rpc';
+import { retryUntil } from '@aztec/foundation/retry';
+
+/**
+ * The SentTx class represents a sent transaction through the AztecRPCClient, providing methods to fetch
+ * its hash, receipt, and mining status.
+ */
+export class SentTx {
+  constructor(private arc: AztecRPC, private 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 AztecRPCClient 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.arc.getTxReceipt(txHash);
+  }
+
+  /**
+   * 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.
+   * Throws an error if the transaction receipt cannot be fetched after the given timeout.
+   *
+   * @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 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 txHash = await this.getTxHash();
+    const receipt = await retryUntil(
+      async () => {
+        const txReceipt = await this.arc.getTxReceipt(txHash);
+        return txReceipt.status != TxStatus.PENDING ? txReceipt : undefined;
+      },
+      'isMined',
+      timeout,
+      interval,
+    );
+    return receipt.status === TxStatus.MINED;
+  }
+}

package/src/contract_deployer/contract_deployer.test.ts

@@ -0,0 +1,56 @@
+import { AztecRPC, Tx, TxHash, TxReceipt } from '@aztec/aztec-rpc';
+import { AztecAddress, EthAddress, Fr, Point } from '@aztec/circuits.js';
+import { ContractAbi, FunctionType } from '@aztec/foundation/abi';
+import { PublicKey } from '@aztec/key-store';
+import { randomBytes } from 'crypto';
+import { MockProxy, mock } from 'jest-mock-extended';
+import { ContractDeployer } from './contract_deployer.js';
+
+describe.skip('Contract Deployer', () => {
+  let arc: MockProxy<AztecRPC>;
+
+  const abi: ContractAbi = {
+    name: 'MyContract',
+    functions: [
+      {
+        name: 'constructor',
+        functionType: FunctionType.SECRET,
+        parameters: [],
+        returnTypes: [],
+        bytecode: '0af',
+      },
+    ],
+  };
+
+  const publicKey: PublicKey = Point.random();
+  const portalContract = new EthAddress(randomBytes(EthAddress.SIZE_IN_BYTES));
+  const contractAddressSalt = Fr.random();
+  const account = AztecAddress.random();
+  const args = [12, 345n];
+
+  const mockTx = { type: 'Tx' } as any as Tx;
+  const mockTxHash = { type: 'TxHash' } as any as TxHash;
+  const mockTxReceipt = { type: 'TxReceipt' } as any as TxReceipt;
+
+  beforeEach(() => {
+    arc = mock<AztecRPC>();
+    arc.sendTx.mockResolvedValue(mockTxHash);
+    arc.getTxReceipt.mockResolvedValue(mockTxReceipt);
+  });
+
+  it('should create and send a contract deployment tx', async () => {
+    const deployer = new ContractDeployer(abi, arc, publicKey);
+    const sentTx = deployer.deploy(args[0], args[1]).send({
+      portalContract,
+      contractAddressSalt,
+      from: account,
+    });
+    const txHash = await sentTx.getTxHash();
+    const receipt = await sentTx.getReceipt();
+
+    expect(txHash).toBe(mockTxHash);
+    expect(receipt).toBe(mockTxReceipt);
+    expect(arc.sendTx).toHaveBeenCalledTimes(1);
+    expect(arc.sendTx).toHaveBeenCalledWith(mockTx);
+  });
+});

package/src/contract_deployer/contract_deployer.ts

@@ -0,0 +1,24 @@
+import { AztecRPC, Point } from '@aztec/aztec-rpc';
+import { ContractAbi } from '@aztec/foundation/abi';
+import { DeployMethod } from './deploy_method.js';
+import { PublicKey } from '@aztec/key-store';
+
+/**
+ * A class for deploying contract.
+ */
+export class ContractDeployer {
+  constructor(private abi: ContractAbi, private arc: AztecRPC, 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, AztecRPCClient, and constructor arguments.
+   */
+  public deploy(...args: any[]) {
+    return new DeployMethod(this.publicKey ?? Point.ZERO, this.arc, this.abi, args);
+  }
+}

package/src/contract_deployer/deploy_method.ts

@@ -0,0 +1,165 @@
+import { AztecRPC, getContractDeploymentInfo } from '@aztec/aztec-rpc';
+import { CircuitsWasm, ContractDeploymentData, TxContext } from '@aztec/circuits.js';
+import { ContractAbi } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { PublicKey } from '@aztec/key-store';
+import { ExecutionRequest, PackedArguments, PartialContractAddress, Tx, TxExecutionRequest } from '@aztec/types';
+import { BaseWallet, Wallet } from '../aztec_rpc_client/wallet.js';
+import { Contract, ContractFunctionInteraction, SendMethodOptions } from '../contract/index.js';
+
+/**
+ * Options for deploying a contract on the Aztec network.
+ * Allows specifying a portal contract, contract address salt, and additional send method options.
+ */
+export interface DeployOptions extends SendMethodOptions {
+  /**
+   * The Ethereum address of the Portal contract.
+   */
+  portalContract?: EthAddress;
+  /**
+   * An optional salt value used to deterministically calculate the contract address.
+   */
+  contractAddressSalt?: Fr;
+}
+
+/**
+ * Simple wallet implementation for use when deploying contracts only.
+ */
+class DeployerWallet extends BaseWallet {
+  getAddress(): AztecAddress {
+    return AztecAddress.ZERO;
+  }
+  async createAuthenticatedTxRequest(
+    executions: ExecutionRequest[],
+    txContext: TxContext,
+  ): Promise<TxExecutionRequest> {
+    if (executions.length !== 1) {
+      throw new Error(`Deployer wallet can only run one execution at a time (requested ${executions.length})`);
+    }
+    const [execution] = executions;
+    const wasm = await CircuitsWasm.get();
+    const packedArguments = await PackedArguments.fromArgs(execution.args, wasm);
+    return Promise.resolve(
+      new TxExecutionRequest(execution.to, execution.functionData, packedArguments.hash, txContext, [packedArguments]),
+    );
+  }
+}
+
+/**
+ * Creates a TxRequest from a contract ABI, for contract deployment.
+ * Extends the ContractFunctionInteraction class.
+ */
+export class DeployMethod extends ContractFunctionInteraction {
+  /**
+   * The partially computed contract address. Known after creation of the deployment transaction.
+   */
+  public partialContractAddress?: PartialContractAddress = undefined;
+
+  /**
+   * The complete contract address.
+   */
+  public completeContractAddress?: AztecAddress = undefined;
+
+  constructor(private publicKey: PublicKey, arc: AztecRPC, private abi: ContractAbi, args: any[] = []) {
+    const constructorAbi = abi.functions.find(f => f.name === 'constructor');
+    if (!constructorAbi) {
+      throw new Error('Cannot find constructor in the ABI.');
+    }
+
+    super(new DeployerWallet(arc), AztecAddress.ZERO, constructorAbi, args);
+  }
+
+  /**
+   * Create a contract deployment transaction, given the deployment options.
+   * This function internally calls `request()` and `sign()` methods to prepare
+   * the transaction for deployment. The resulting signed transaction can be
+   * later sent using the `send()` method.
+   *
+   * @param options - An object containing optional deployment settings, including portalContract, contractAddressSalt, and from.
+   * @returns A Promise resolving to an object containing the signed transaction data and other relevant information.
+   */
+  public async create(options: DeployOptions = {}) {
+    const { portalContract, contractAddressSalt } = Object.assign(
+      { portalContract: EthAddress.ZERO, contractAddressSalt: Fr.random() },
+      options,
+    );
+
+    const { address, constructorHash, functionTreeRoot, partialAddress } = await getContractDeploymentInfo(
+      this.abi,
+      this.args,
+      contractAddressSalt,
+      this.publicKey,
+    );
+
+    const contractDeploymentData = new ContractDeploymentData(
+      this.publicKey,
+      constructorHash,
+      functionTreeRoot,
+      contractAddressSalt,
+      portalContract,
+    );
+
+    const { chainId, version } = await this.wallet.getNodeInfo();
+
+    const txContext = new TxContext(false, false, true, contractDeploymentData, new Fr(chainId), new Fr(version));
+    const executionRequest = this.getExecutionRequest(address, AztecAddress.ZERO);
+    const txRequest = await this.wallet.createAuthenticatedTxRequest([executionRequest], txContext);
+
+    this.txRequest = txRequest;
+    this.partialContractAddress = partialAddress;
+    this.completeContractAddress = address;
+
+    // TODO: Should we add the contracts to the DB here, or once the tx has been sent or mined?
+    await this.wallet.addContracts([{ abi: this.abi, address, portalContract }]);
+
+    return this.txRequest;
+  }
+
+  /**
+   * Send the contract deployment transaction using the provided options.
+   * This function extends the 'send' method from the ContractFunctionInteraction class,
+   * allowing us to send a transaction specifically for contract deployment.
+   *
+   * @param options - An object containing various deployment options such as portalContract, contractAddressSalt, and from.
+   * @returns A Promise that resolves to the transaction receipt upon successful deployment.
+   */
+  public send(options: DeployOptions = {}) {
+    return super.send(options);
+  }
+
+  /**
+   * Simulate the request.
+   * @param options - Deployment options.
+   * @returns The simulated tx.
+   */
+  public async simulate(options: DeployOptions): Promise<Tx> {
+    const txRequest = this.txRequest ?? (await this.create(options));
+
+    // We need to tell the rpc server which account state to use to simulate
+    // the tx. In the context of a deployment, we need to use an account state
+    // that matches the account contract being deployed. But if what we deploy is
+    // an "application" contract, then there's no account state associated with it,
+    // so we just let the rpc server use whichever it wants. This is an accident
+    // of all simulations happening over an account state, which should not be necessary.
+    const rpcServerRegisteredAccounts = await this.wallet.getAccounts();
+    const deploymentAddress = this.completeContractAddress!;
+    const accountStateAddress = rpcServerRegisteredAccounts.includes(deploymentAddress) ? deploymentAddress : undefined;
+
+    this.tx = await this.wallet.simulateTx(txRequest, accountStateAddress);
+    return this.tx;
+  }
+
+  /**
+   * Creates a contract abstraction given a wallet.
+   * @param withWallet - The wallet to provide to the contract abstraction
+   * @returns - The generated contract abstraction.
+   */
+  public 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);
+  }
+}

package/src/contract_deployer/index.ts

@@ -0,0 +1 @@
+export * from './contract_deployer.js';

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './contract/index.js';
+export * from './contract_deployer/index.js';
+export * from './utils/index.js';
+export * from './aztec_rpc_client/index.js';
+export * from './auth/index.js';
+export * from './account_impl/index.js';
+
+// TODO - only export necessary stuffs
+export * from '@aztec/aztec-rpc';

package/src/utils/account.ts

@@ -0,0 +1,59 @@
+import { AztecRPC, TxStatus, getContractDeploymentInfo } from '@aztec/aztec-rpc';
+import { AztecAddress, CircuitsWasm, Fr, Point } from '@aztec/circuits.js';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { EcdsaAccountContractAbi } from '@aztec/noir-contracts/examples';
+import { AccountWallet, Wallet } from '../aztec_rpc_client/wallet.js';
+import {
+  AccountCollection,
+  AccountContract,
+  ContractDeployer,
+  EcdsaAuthProvider,
+  generatePublicKey,
+} from '../index.js';
+
+/**
+ * Creates an Aztec Account.
+ * @returns The account's address & public key.
+ */
+export async function createAccounts(
+  aztecRpcClient: AztecRPC,
+  privateKey?: Buffer,
+  numberOfAccounts = 1,
+  logger = createDebugLogger('aztec:aztec.js:accounts'),
+): Promise<Wallet> {
+  const accountImpls = new AccountCollection();
+  const results: [AztecAddress, Point][] = [];
+  const wasm = await CircuitsWasm.get();
+  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 accountAbi = EcdsaAccountContractAbi;
+    const publicKey = await generatePublicKey(privKey);
+    const salt = Fr.random();
+    const deploymentInfo = await getContractDeploymentInfo(accountAbi, [], salt, publicKey);
+    await aztecRpcClient.addAccount(privKey, deploymentInfo.address, deploymentInfo.partialAddress, accountAbi);
+    const contractDeployer = new ContractDeployer(accountAbi, aztecRpcClient, publicKey);
+    const tx = contractDeployer.deploy().send({ contractAddressSalt: salt });
+    await tx.isMined(0, 0.1);
+    const receipt = await tx.getReceipt();
+    if (receipt.status !== TxStatus.MINED) {
+      throw new Error(`Deployment tx not mined (status is ${receipt.status})`);
+    }
+    const address = receipt.contractAddress!;
+    logger(`Created account ${address.toString()} with public key ${publicKey.toString()}`);
+    accountImpls.registerAccount(
+      address,
+      new AccountContract(
+        address,
+        publicKey,
+        new EcdsaAuthProvider(privKey),
+        deploymentInfo.partialAddress,
+        accountAbi,
+        wasm,
+      ),
+    );
+    results.push([address, publicKey]);
+  }
+  return new AccountWallet(aztecRpcClient, accountImpls);
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './secrets.js';
+export * from './account.js';
+export * from './pub_key.js';

package/src/utils/pub_key.ts

@@ -0,0 +1,26 @@
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+import { Point } from '../index.js';
+
+/**
+ * Converts a Point type to a public key represented by BigInt coordinates
+ * @param point - The Point to convert.
+ * @returns An object with x & y coordinates represented as bigints.
+ */
+export function pointToPublicKey(point: Point) {
+  const x = point.x.toBigInt();
+  const y = point.y.toBigInt();
+  return {
+    x,
+    y,
+  };
+}
+
+/**
+ * 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> {
+  const grumpkin = await Grumpkin.new();
+  return Point.fromBuffer(grumpkin.mul(grumpkin.generator(), privateKey));
+}

package/src/utils/secrets.ts

@@ -0,0 +1,12 @@
+import { CircuitsWasm, Fr } from '@aztec/circuits.js';
+import { computeSecretMessageHash } from '@aztec/circuits.js/abis';
+
+/**
+ * Given a secret, it computes its pedersen hash - used to send l1 to l2 messages
+ * @param secret - the secret to hash - secret could be generated however you want e.g. `Fr.random()`
+ * @returns the hash
+ */
+export async function computeMessageSecretHash(secret: Fr): Promise<Fr> {
+  const wasm = await CircuitsWasm.get();
+  return computeSecretMessageHash(wasm, secret);
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "extends": "..",
+  "compilerOptions": {
+    "outDir": "dest",
+    "rootDir": "src",
+    "tsBuildInfoFile": ".tsbuildinfo"
+  },
+  "references": [
+    {
+      "path": "../aztec-rpc"
+    },
+    {
+      "path": "../circuits.js"
+    },
+    {
+      "path": "../foundation"
+    },
+    {
+      "path": "../key-store"
+    },
+    {
+      "path": "../noir-contracts"
+    }
+  ],
+  "include": ["src"]
+}