@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/contract/wait_opts.ts

@@ -0,0 +1,21 @@
+import type { TxStatus } from '@aztec/stdlib/tx';
+
+/** Options related to waiting for a tx. */
+export type WaitOpts = {
+  /** The amount of time to ignore TxStatus.DROPPED receipts (in seconds) due to the presumption that it is being propagated by the p2p network. Defaults to 5. */
+  ignoreDroppedReceiptsFor?: number;
+  /** 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 accept a revert as a status code for the tx when waiting for it. If false, will throw if the tx reverts. */
+  dontThrowOnRevert?: boolean;
+  /** The minimum inclusion status to wait for. If set, waits until the receipt reaches this status or higher. Defaults to CHECKPOINTED. */
+  waitForStatus?: TxStatus;
+};
+
+export const DefaultWaitOpts: WaitOpts = {
+  ignoreDroppedReceiptsFor: 5,
+  timeout: 300,
+  interval: 1,
+};

package/src/deployment/broadcast_function.ts

@@ -1,26 +1,26 @@
 import {
   ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
+  CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT,
   MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
-  REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { type ContractArtifact, FunctionSelector, FunctionType, bufferAsFields } from '@aztec/stdlib/abi';
 import {
   computeVerificationKeyHash,
   createPrivateFunctionMembershipProof,
-  createUnconstrainedFunctionMembershipProof,
+  createUtilityFunctionMembershipProof,
   getContractClassFromArtifact,
 } from '@aztec/stdlib/contract';
 import { Capsule } from '@aztec/stdlib/tx';
 
 import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { getRegistererContract } from '../contract/protocol_contracts.js';
+import { ContractClassRegistryContract } from '../contract/protocol_contracts/contract-class-registry.js';
 import type { Wallet } from '../wallet/index.js';
 
 /**
- * Sets up a call to broadcast a private function's bytecode via the ClassRegisterer contract.
+ * Sets up a call to broadcast a private function's bytecode via the ClassRegistry contract.
  * Note that this is not required for users to call the function, but is rather a convenience to make
  * this code publicly available so dapps or wallets do not need to redistribute it.
  * @param wallet - Wallet to send the transaction.
@@ -51,43 +51,43 @@ export async function broadcastPrivateFunction(
     artifactTreeLeafIndex,
     artifactMetadataHash,
     functionMetadataHash,
-    unconstrainedFunctionsArtifactTreeRoot,
+    utilityFunctionsTreeRoot,
     privateFunctionTreeSiblingPath,
     privateFunctionTreeLeafIndex,
   } = await createPrivateFunctionMembershipProof(selector, artifact);
 
   const vkHash = await computeVerificationKeyHash(privateFunctionArtifact);
 
-  const registerer = await getRegistererContract(wallet);
-  const fn = registerer.methods.broadcast_private_function(
-    contractClass.id,
-    artifactMetadataHash,
-    unconstrainedFunctionsArtifactTreeRoot,
-    privateFunctionTreeSiblingPath,
-    privateFunctionTreeLeafIndex,
-    padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-    artifactTreeLeafIndex,
-    // eslint-disable-next-line camelcase
-    { selector, metadata_hash: functionMetadataHash, vk_hash: vkHash },
-  );
-
+  const classRegistry = ContractClassRegistryContract.at(wallet);
   const bytecode = bufferAsFields(
     privateFunctionArtifact.bytecode,
     MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
   );
-  fn.addCapsule(
-    new Capsule(
-      ProtocolContractAddress.ContractClassRegisterer,
-      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
-      bytecode,
-    ),
-  );
-
-  return fn;
+  return classRegistry.methods
+    .broadcast_private_function(
+      contractClass.id,
+      artifactMetadataHash,
+      utilityFunctionsTreeRoot,
+      privateFunctionTreeSiblingPath,
+      privateFunctionTreeLeafIndex,
+      padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+      artifactTreeLeafIndex,
+      // eslint-disable-next-line camelcase
+      { selector, metadata_hash: functionMetadataHash, vk_hash: vkHash },
+    )
+    .with({
+      capsules: [
+        new Capsule(
+          ProtocolContractAddress.ContractClassRegistry,
+          new Fr(CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT),
+          bytecode,
+        ),
+      ],
+    });
 }
 
 /**
- * Sets up a call to broadcast an unconstrained function's bytecode via the ClassRegisterer contract.
+ * Sets up a call to broadcast a utility function's bytecode via the ClassRegistry contract.
  * Note that this is not required for users to call the function, but is rather a convenience to make
  * this code publicly available so dapps or wallets do not need to redistribute it.
  * @param wallet - Wallet to send the transaction.
@@ -95,22 +95,22 @@ export async function broadcastPrivateFunction(
  * @param selector - Selector of the function to be broadcast.
  * @returns A ContractFunctionInteraction object that can be used to send the transaction.
  */
-export async function broadcastUnconstrainedFunction(
+export async function broadcastUtilityFunction(
   wallet: Wallet,
   artifact: ContractArtifact,
   selector: FunctionSelector,
 ): Promise<ContractFunctionInteraction> {
   const contractClass = await getContractClassFromArtifact(artifact);
-  const unconstrainedFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.UNCONSTRAINED);
-  const unconstrainedFunctionsAndSelectors = await Promise.all(
-    unconstrainedFunctions.map(async fn => ({
+  const utilityFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.UTILITY);
+  const utilityFunctionsAndSelectors = await Promise.all(
+    utilityFunctions.map(async fn => ({
       f: fn,
       selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters),
     })),
   );
-  const unconstrainedFunctionArtifact = unconstrainedFunctionsAndSelectors.find(fn => selector.equals(fn.selector))?.f;
-  if (!unconstrainedFunctionArtifact) {
-    throw new Error(`Unconstrained function with selector ${selector.toString()} not found`);
+  const utilityFunctionArtifact = utilityFunctionsAndSelectors.find(fn => selector.equals(fn.selector))?.f;
+  if (!utilityFunctionArtifact) {
+    throw new Error(`Utility function with selector ${selector.toString()} not found`);
   }
 
   const {
@@ -119,30 +119,30 @@ export async function broadcastUnconstrainedFunction(
     artifactTreeSiblingPath,
     functionMetadataHash,
     privateFunctionsArtifactTreeRoot,
-  } = await createUnconstrainedFunctionMembershipProof(selector, artifact);
-
-  const registerer = await getRegistererContract(wallet);
-  const fn = registerer.methods.broadcast_unconstrained_function(
-    contractClass.id,
-    artifactMetadataHash,
-    privateFunctionsArtifactTreeRoot,
-    padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-    artifactTreeLeafIndex,
-    // eslint-disable-next-line camelcase
-    { selector, metadata_hash: functionMetadataHash },
-  );
+  } = await createUtilityFunctionMembershipProof(selector, artifact);
 
+  const classRegistry = ContractClassRegistryContract.at(wallet);
   const bytecode = bufferAsFields(
-    unconstrainedFunctionArtifact.bytecode,
+    utilityFunctionArtifact.bytecode,
     MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
   );
-  fn.addCapsule(
-    new Capsule(
-      ProtocolContractAddress.ContractClassRegisterer,
-      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
-      bytecode,
-    ),
-  );
-
-  return fn;
+  return classRegistry.methods
+    .broadcast_utility_function(
+      contractClass.id,
+      artifactMetadataHash,
+      privateFunctionsArtifactTreeRoot,
+      padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+      artifactTreeLeafIndex,
+      // eslint-disable-next-line camelcase
+      { selector, metadata_hash: functionMetadataHash },
+    )
+    .with({
+      capsules: [
+        new Capsule(
+          ProtocolContractAddress.ContractClassRegistry,
+          new Fr(CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT),
+          bytecode,
+        ),
+      ],
+    });
 }

package/src/deployment/contract_deployer.ts

@@ -1,10 +1,10 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { PublicKeys } from '@aztec/stdlib/keys';
 
-import type { Wallet } from '../account/wallet.js';
 import { Contract } from '../contract/contract.js';
 import { DeployMethod } from '../contract/deploy_method.js';
+import type { Wallet } from '../wallet/wallet.js';
 
 /**
  * A class for deploying contract.
@@ -28,7 +28,8 @@ export class ContractDeployer {
    * @returns A DeployMethod instance configured with the ABI, PXE, and constructor arguments.
    */
   public deploy(...args: any[]) {
-    const postDeployCtor = (address: AztecAddress, wallet: Wallet) => Contract.at(address, this.artifact, wallet);
+    const postDeployCtor = (instance: ContractInstanceWithAddress, wallet: Wallet) =>
+      Contract.at(instance.address, this.artifact, wallet);
     return new DeployMethod(
       this.publicKeys ?? PublicKeys.default(),
       this.wallet,

package/src/deployment/publish_class.ts

@@ -0,0 +1,34 @@
+import {
+  CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT,
+  MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { type ContractArtifact, bufferAsFields } from '@aztec/stdlib/abi';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { Capsule } from '@aztec/stdlib/tx';
+
+import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { ContractClassRegistryContract } from '../contract/protocol_contracts/contract-class-registry.js';
+import type { Wallet } from '../wallet/index.js';
+
+/** Sets up a call to publish a contract class given its artifact. */
+export async function publishContractClass(
+  wallet: Wallet,
+  artifact: ContractArtifact,
+): Promise<ContractFunctionInteraction> {
+  const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode } =
+    await getContractClassFromArtifact(artifact);
+  const classRegistry = ContractClassRegistryContract.at(wallet);
+
+  const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
+  return classRegistry.methods.publish(artifactHash, privateFunctionsRoot, publicBytecodeCommitment).with({
+    capsules: [
+      new Capsule(
+        ProtocolContractAddress.ContractClassRegistry,
+        new Fr(CONTRACT_CLASS_REGISTRY_BYTECODE_CAPSULE_SLOT),
+        encodedBytecode,
+      ),
+    ],
+  });
+}

package/src/deployment/publish_instance.ts

@@ -0,0 +1,23 @@
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { ContractInstanceRegistryContract } from '../contract/protocol_contracts/contract-instance-registry.js';
+import type { Wallet } from '../wallet/wallet.js';
+
+/**
+ * Sets up a call to the canonical contract instance registry to publish a contract instance.
+ * @param wallet - The wallet to use for the publication (setup) tx.
+ * @param instance - The instance to publish.
+ */
+export function publishInstance(wallet: Wallet, instance: ContractInstanceWithAddress): ContractFunctionInteraction {
+  const contractInstanceRegistry = ContractInstanceRegistryContract.at(wallet);
+  const { salt, currentContractClassId: contractClassId, publicKeys, deployer: instanceDeployer } = instance;
+  const isUniversalDeploy = instanceDeployer.isZero();
+  return contractInstanceRegistry.methods.publish_for_public_execution(
+    salt,
+    contractClassId,
+    instance.initializationHash,
+    publicKeys,
+    isUniversalDeploy,
+  );
+}