@aztec/aztec.js 0.0.0-test.0

package/src/contract/unsafe_contract.ts

@@ -0,0 +1,19 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import type { Wallet } from '../wallet/index.js';
+import { ContractBase } from './contract_base.js';
+
+/** Unsafe constructor for ContractBase that bypasses the check that the instance is registered in the wallet. */
+export class UnsafeContract extends ContractBase {
+  constructor(
+    /** The deployed contract instance definition. */
+    instance: ContractInstanceWithAddress,
+    /** The Application Binary Interface for the contract. */
+    artifact: ContractArtifact,
+    /** The wallet used for interacting with this contract. */
+    wallet: Wallet,
+  ) {
+    super(instance, artifact, wallet);
+  }
+}

package/src/deployment/broadcast_function.ts

@@ -0,0 +1,148 @@
+import {
+  ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
+  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 { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { type ContractArtifact, FunctionSelector, FunctionType, bufferAsFields } from '@aztec/stdlib/abi';
+import {
+  computeVerificationKeyHash,
+  createPrivateFunctionMembershipProof,
+  createUnconstrainedFunctionMembershipProof,
+  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 type { Wallet } from '../wallet/index.js';
+
+/**
+ * Sets up a call to broadcast a private function's bytecode via the ClassRegisterer 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.
+ * @param artifact - Contract artifact that contains the function to be broadcast.
+ * @param selector - Selector of the function to be broadcast.
+ * @returns A ContractFunctionInteraction object that can be used to send the transaction.
+ */
+export async function broadcastPrivateFunction(
+  wallet: Wallet,
+  artifact: ContractArtifact,
+  selector: FunctionSelector,
+): Promise<ContractFunctionInteraction> {
+  const contractClass = await getContractClassFromArtifact(artifact);
+  const privateFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.PRIVATE);
+  const functionsAndSelectors = await Promise.all(
+    privateFunctions.map(async fn => ({
+      f: fn,
+      selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters),
+    })),
+  );
+  const privateFunctionArtifact = functionsAndSelectors.find(fn => selector.equals(fn.selector))?.f;
+  if (!privateFunctionArtifact) {
+    throw new Error(`Private function with selector ${selector.toString()} not found`);
+  }
+
+  const {
+    artifactTreeSiblingPath,
+    artifactTreeLeafIndex,
+    artifactMetadataHash,
+    functionMetadataHash,
+    unconstrainedFunctionsArtifactTreeRoot,
+    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 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;
+}
+
+/**
+ * Sets up a call to broadcast an unconstrained function's bytecode via the ClassRegisterer 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.
+ * @param artifact - Contract artifact that contains the function to be broadcast.
+ * @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(
+  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 => ({
+      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 {
+    artifactMetadataHash,
+    artifactTreeLeafIndex,
+    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 },
+  );
+
+  const bytecode = bufferAsFields(
+    unconstrainedFunctionArtifact.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;
+}

package/src/deployment/contract_deployer.ts

@@ -0,0 +1,41 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+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';
+
+/**
+ * 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 wallet: Wallet,
+    private publicKeys?: PublicKeys,
+    private constructorName?: string,
+  ) {}
+
+  /**
+   * 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[]) {
+    const postDeployCtor = (address: AztecAddress, wallet: Wallet) => Contract.at(address, this.artifact, wallet);
+    return new DeployMethod(
+      this.publicKeys ?? PublicKeys.default(),
+      this.wallet,
+      this.artifact,
+      postDeployCtor,
+      args,
+      this.constructorName,
+    );
+  }
+}

package/src/deployment/deploy_instance.ts

@@ -0,0 +1,31 @@
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { getDeployerContract } from '../contract/protocol_contracts.js';
+import type { Wallet } from '../wallet/index.js';
+
+/**
+ * Sets up a call to the canonical deployer contract to publicly deploy a contract instance.
+ * @param wallet - The wallet to use for the deployment.
+ * @param instance - The instance to deploy.
+ */
+export async function deployInstance(
+  wallet: Wallet,
+  instance: ContractInstanceWithAddress,
+): Promise<ContractFunctionInteraction> {
+  const deployerContract = await getDeployerContract(wallet);
+  const { salt, currentContractClassId: contractClassId, publicKeys, deployer } = instance;
+  const isUniversalDeploy = deployer.isZero();
+  if (!isUniversalDeploy && !wallet.getAddress().equals(deployer)) {
+    throw new Error(
+      `Expected deployer ${deployer.toString()} does not match sender wallet ${wallet.getAddress().toString()}`,
+    );
+  }
+  return deployerContract.methods.deploy(
+    salt,
+    contractClassId,
+    instance.initializationHash,
+    publicKeys,
+    isUniversalDeploy,
+  );
+}

package/src/deployment/index.ts

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

package/src/deployment/register_class.ts

@@ -0,0 +1,44 @@
+import { MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS, REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+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 { getRegistererContract } from '../contract/protocol_contracts.js';
+import type { Wallet } from '../wallet/index.js';
+
+const defaultEmitPublicBytecode =
+  // guard against `process` not being defined (e.g. in the browser)
+  typeof process === 'object' && typeof process.env === 'object'
+    ? ['1', 'true', 'yes', ''].includes(process.env.AZTEC_EMIT_PUBLIC_BYTECODE ?? '')
+    : true;
+
+/** Sets up a call to register a contract class given its artifact. */
+export async function registerContractClass(
+  wallet: Wallet,
+  artifact: ContractArtifact,
+  emitPublicBytecode = defaultEmitPublicBytecode,
+): Promise<ContractFunctionInteraction> {
+  const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode } =
+    await getContractClassFromArtifact(artifact);
+  const registerer = await getRegistererContract(wallet);
+  const fn = registerer.methods.register(
+    artifactHash,
+    privateFunctionsRoot,
+    publicBytecodeCommitment,
+    emitPublicBytecode,
+  );
+
+  const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
+  fn.addCapsule(
+    new Capsule(
+      ProtocolContractAddress.ContractClassRegisterer,
+      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
+      encodedBytecode,
+    ),
+  );
+
+  return fn;
+}

package/src/entrypoint/default_entrypoint.ts

@@ -0,0 +1,39 @@
+import { FunctionType } from '@aztec/stdlib/abi';
+import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
+
+import type { EntrypointInterface, ExecutionRequestInit } from './entrypoint.js';
+
+/**
+ * Default implementation of the entrypoint interface. It calls a function on a contract directly
+ */
+export class DefaultEntrypoint implements EntrypointInterface {
+  constructor(private chainId: number, private protocolVersion: number) {}
+
+  async createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
+    const { fee, calls, authWitnesses = [], hashedArguments = [], capsules = [] } = exec;
+
+    if (calls.length > 1) {
+      throw new Error(`Expected a single call, got ${calls.length}`);
+    }
+
+    const call = calls[0];
+
+    if (call.type !== FunctionType.PRIVATE) {
+      throw new Error('Public entrypoints are not allowed');
+    }
+
+    const entrypointHashedValues = await HashedValues.fromValues(call.args);
+    const txContext = new TxContext(this.chainId, this.protocolVersion, fee.gasSettings);
+    return Promise.resolve(
+      new TxExecutionRequest(
+        call.to,
+        call.selector,
+        entrypointHashedValues.hash,
+        txContext,
+        [...hashedArguments, entrypointHashedValues],
+        authWitnesses,
+        capsules,
+      ),
+    );
+  }
+}

package/src/entrypoint/default_multi_call_entrypoint.ts

@@ -0,0 +1,93 @@
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { type FunctionAbi, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
+
+import { type EntrypointInterface, EntrypointPayload, type ExecutionRequestInit } from './entrypoint.js';
+
+/**
+ * Implementation for an entrypoint interface that can execute multiple function calls in a single transaction
+ */
+export class DefaultMultiCallEntrypoint implements EntrypointInterface {
+  constructor(
+    private chainId: number,
+    private version: number,
+    private address: AztecAddress = ProtocolContractAddress.MultiCallEntrypoint,
+  ) {}
+
+  async createTxExecutionRequest(executions: ExecutionRequestInit): Promise<TxExecutionRequest> {
+    const { fee, calls, authWitnesses = [], hashedArguments = [], capsules = [] } = executions;
+    const payload = await EntrypointPayload.fromAppExecution(calls);
+    const abi = this.getEntrypointAbi();
+    const entrypointHashedArgs = await HashedValues.fromValues(encodeArguments(abi, [payload]));
+
+    const txRequest = TxExecutionRequest.from({
+      firstCallArgsHash: entrypointHashedArgs.hash,
+      origin: this.address,
+      functionSelector: await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters),
+      txContext: new TxContext(this.chainId, this.version, fee.gasSettings),
+      argsOfCalls: [...payload.hashedArguments, ...hashedArguments, entrypointHashedArgs],
+      authWitnesses,
+      capsules,
+    });
+
+    return Promise.resolve(txRequest);
+  }
+
+  private getEntrypointAbi() {
+    return {
+      name: 'entrypoint',
+      isInitializer: false,
+      functionType: 'private',
+      isInternal: false,
+      isStatic: false,
+      parameters: [
+        {
+          name: 'app_payload',
+          type: {
+            kind: 'struct',
+            path: 'authwit::entrypoint::app::AppPayload',
+            fields: [
+              {
+                name: 'function_calls',
+                type: {
+                  kind: 'array',
+                  length: 4,
+                  type: {
+                    kind: 'struct',
+                    path: 'authwit::entrypoint::function_call::FunctionCall',
+                    fields: [
+                      { name: 'args_hash', type: { kind: 'field' } },
+                      {
+                        name: 'function_selector',
+                        type: {
+                          kind: 'struct',
+                          path: 'authwit::aztec::protocol_types::abis::function_selector::FunctionSelector',
+                          fields: [{ name: 'inner', type: { kind: 'integer', sign: 'unsigned', width: 32 } }],
+                        },
+                      },
+                      {
+                        name: 'target_address',
+                        type: {
+                          kind: 'struct',
+                          path: 'authwit::aztec::protocol_types::address::AztecAddress',
+                          fields: [{ name: 'inner', type: { kind: 'field' } }],
+                        },
+                      },
+                      { name: 'is_public', type: { kind: 'boolean' } },
+                      { name: 'is_static', type: { kind: 'boolean' } },
+                    ],
+                  },
+                },
+              },
+              { name: 'nonce', type: { kind: 'field' } },
+            ],
+          },
+          visibility: 'public',
+        },
+      ],
+      returnTypes: [],
+      errorTypes: {},
+    } as FunctionAbi;
+  }
+}

package/src/entrypoint/entrypoint.ts

@@ -0,0 +1,39 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionCall } from '@aztec/stdlib/abi';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { Capsule, HashedValues, TxExecutionRequest } from '@aztec/stdlib/tx';
+
+import { EntrypointPayload, type FeeOptions, computeCombinedPayloadHash } from './payload.js';
+
+export { EntrypointPayload, type FeeOptions, computeCombinedPayloadHash };
+
+export { DefaultEntrypoint } from './default_entrypoint.js';
+export { DefaultMultiCallEntrypoint } from './default_multi_call_entrypoint.js';
+
+/** Encodes the calls to be done in a transaction. */
+export type ExecutionRequestInit = {
+  /** The function calls to be executed. */
+  calls: FunctionCall[];
+  /** Any transient auth witnesses needed for this execution */
+  authWitnesses?: AuthWitness[];
+  /** Any transient hashed arguments for this execution */
+  hashedArguments?: HashedValues[];
+  /** Data passed through an oracle for this execution. */
+  capsules?: Capsule[];
+  /** How the fee is going to be payed */
+  fee: FeeOptions;
+  /** An optional nonce. Used to repeat a previous tx with a higher fee so that the first one is cancelled */
+  nonce?: Fr;
+  /** Whether the transaction can be cancelled. If true, an extra nullifier will be emitted: H(nonce, GENERATOR_INDEX__TX_NULLIFIER) */
+  cancellable?: boolean;
+};
+
+/** Creates transaction execution requests out of a set of function calls. */
+export interface EntrypointInterface {
+  /**
+   * Generates an execution request out of set of function calls.
+   * @param execution - The execution intents to be run.
+   * @returns The authenticated transaction execution request.
+   */
+  createTxExecutionRequest(execution: ExecutionRequestInit): Promise<TxExecutionRequest>;
+}