@aztec/aztec.js 0.0.1-commit.d3ec352c → 0.0.1-commit.f295ac2

package/src/wallet/wallet.ts

@@ -1,6 +1,8 @@
 import type { ChainInfo } from '@aztec/entrypoints/interfaces';
-import type { Fr } from '@aztec/foundation/fields';
+import { BlockNumber, BlockNumberPositiveSchema } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import {
+  type AbiDecoded,
   AbiTypeSchema,
   type ContractArtifact,
   ContractArtifactSchema,
@@ -10,15 +12,9 @@ import {
 } from '@aztec/stdlib/abi';
 import { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import {
-  type ContractClassMetadata,
-  ContractClassWithIdSchema,
-  type ContractInstanceWithAddress,
-  ContractInstanceWithAddressSchema,
-  type ContractMetadata,
-} from '@aztec/stdlib/contract';
+import { type ContractInstanceWithAddress, ContractInstanceWithAddressSchema } from '@aztec/stdlib/contract';
 import { Gas } from '@aztec/stdlib/gas';
-import { AbiDecodedSchema, type ApiSchemaFor, type ZodFor, optional, schemas } from '@aztec/stdlib/schemas';
+import { AbiDecodedSchema, type ApiSchemaFor, optional, schemas, zodFor } from '@aztec/stdlib/schemas';
 import {
   Capsule,
   HashedValues,
@@ -27,8 +23,9 @@ import {
   TxReceipt,
   TxSimulationResult,
   UtilitySimulationResult,
+  inTxSchema,
 } from '@aztec/stdlib/tx';
-import type { ExecutionPayload } from '@aztec/stdlib/tx';
+import type { ExecutionPayload, InTx } from '@aztec/stdlib/tx';
 
 import { z } from 'zod';
 
@@ -57,7 +54,7 @@ export type Aliased<T> = {
 
 /**
  * Options for simulating interactions with the wallet. Overrides the fee settings of an interaction with
- * a simplified version that only hints at the wallet wether the interaction contains a
+ * a simplified version that only hints at the wallet whether the interaction contains a
  * fee payment method or not
  */
 export type SimulateOptions = Omit<SimulateInteractionOptions, 'fee'> & {
@@ -67,7 +64,7 @@ export type SimulateOptions = Omit<SimulateInteractionOptions, 'fee'> & {
 
 /**
  * Options for profiling interactions with the wallet. Overrides the fee settings of an interaction with
- * a simplified version that only hints at the wallet wether the interaction contains a
+ * a simplified version that only hints at the wallet whether the interaction contains a
  * fee payment method or not
  */
 export type ProfileOptions = Omit<ProfileInteractionOptions, 'fee'> & {
@@ -77,7 +74,7 @@ export type ProfileOptions = Omit<ProfileInteractionOptions, 'fee'> & {
 
 /**
  * Options for sending/proving interactions with the wallet. Overrides the fee settings of an interaction with
- * a simplified version that only hints at the wallet wether the interaction contains a
+ * a simplified version that only hints at the wallet whether the interaction contains a
  * fee payment method or not
  */
 export type SendOptions = Omit<SendInteractionOptions, 'fee'> & {
@@ -86,36 +83,40 @@ export type SendOptions = Omit<SendInteractionOptions, 'fee'> & {
 };
 
 /**
- * Helper type that represents all methods that can be batched.
+ * Helper type that represents all methods that can be batched (all methods except batch itself).
  */
-export type BatchableMethods = Pick<
-  Wallet,
-  'registerContract' | 'sendTx' | 'registerSender' | 'simulateUtility' | 'simulateTx'
->;
+export type BatchableMethods = Omit<Wallet, 'batch'>;
 
 /**
- * From the batchable methods, we create a type that represents a method call with its name and arguments.
- * This is what the wallet will accept as arguments to the `batch` method.
+ * A method call with its name and arguments.
  */
-export type BatchedMethod<T extends keyof BatchableMethods> = {
+type BatchedMethodInternal<T extends keyof BatchableMethods> = {
   /** The method name */
   name: T;
   /** The method arguments */
   args: Parameters<BatchableMethods[T]>;
 };
 
+/**
+ * Union of all possible batched method calls.
+ * This ensures type safety: the `args` must match the specific `name`.
+ */
+export type BatchedMethod = {
+  [K in keyof BatchableMethods]: BatchedMethodInternal<K>;
+}[keyof BatchableMethods];
+
 /**
  * Helper type to extract the return type of a batched method
  */
 export type BatchedMethodResult<T> =
-  T extends BatchedMethod<infer K> ? Awaited<ReturnType<BatchableMethods[K]>> : never;
+  T extends BatchedMethodInternal<infer K> ? Awaited<ReturnType<BatchableMethods[K]>> : never;
 
 /**
  * Wrapper type for batch results that includes the method name for discriminated union deserialization.
  * Each result is wrapped as \{ name: 'methodName', result: ActualResult \} to allow proper deserialization
  * when AztecAddress and TxHash would otherwise be ambiguous (both are hex strings).
  */
-export type BatchedMethodResultWrapper<T extends BatchedMethod<keyof BatchableMethods>> = {
+export type BatchedMethodResultWrapper<T extends BatchedMethod> = {
   /** The method name */
   name: T['name'];
   /** The method result */
@@ -125,25 +126,80 @@ export type BatchedMethodResultWrapper<T extends BatchedMethod<keyof BatchableMe
 /**
  * Maps a tuple of BatchedMethod to a tuple of their wrapped return types
  */
-export type BatchResults<T extends readonly BatchedMethod<keyof BatchableMethods>[]> = {
+export type BatchResults<T extends readonly BatchedMethod[]> = {
   [K in keyof T]: BatchedMethodResultWrapper<T[K]>;
 };
 
+/**
+ * Filter options when querying private events.
+ */
+export type PrivateEventFilter = {
+  /** The address of the contract that emitted the events. */
+  contractAddress: AztecAddress;
+  /** Addresses of accounts that are in scope for this filter. */
+  scopes: AztecAddress[];
+  /** Transaction in which the events were emitted. */
+  txHash?: TxHash;
+  /** The block number from which to start fetching events (inclusive).
+   * Optional. If provided, it must be greater or equal than 1.
+   * Defaults to the initial L2 block number (INITIAL_L2_BLOCK_NUM).
+   * */
+  fromBlock?: BlockNumber;
+  /** The block number until which to fetch logs (not inclusive).
+   * Optional. If provided, it must be greater than fromBlock.
+   * Defaults to the latest known block to PXE + 1.
+   */
+  toBlock?: BlockNumber;
+};
+
+/**
+ * An ABI decoded private event with associated metadata.
+ */
+export type PrivateEvent<T> = {
+  /** The ABI decoded event */
+  event: T;
+  /** Metadata describing event context information such as tx and block */
+  metadata: InTx;
+};
+
+/**
+ * Contract metadata including deployment and registration status.
+ */
+export type ContractMetadata = {
+  /** The contract instance */
+  instance?: ContractInstanceWithAddress;
+  /** Whether the contract has been initialized (init nullifier exists) */
+  isContractInitialized: boolean;
+  /** Whether the contract instance is publicly deployed on-chain */
+  isContractPublished: boolean;
+  /** Whether the contract has been updated to a different class */
+  isContractUpdated: boolean;
+  /** The updated contract class ID if the contract has been updated */
+  updatedContractClassId?: Fr | undefined;
+};
+
+/**
+ * Contract class metadata.
+ */
+export type ContractClassMetadata = {
+  /** Whether the artifact is registered in the wallet */
+  isArtifactRegistered: boolean;
+  /** Whether the contract class is publicly registered on-chain */
+  isContractClassPubliclyRegistered: boolean;
+};
+
 /**
  * The wallet interface.
  */
 export type Wallet = {
-  getContractClassMetadata(id: Fr, includeArtifact?: boolean): Promise<ContractClassMetadata>;
-  getContractMetadata(address: AztecAddress): Promise<ContractMetadata>;
   getPrivateEvents<T>(
-    contractAddress: AztecAddress,
     eventMetadata: EventMetadataDefinition,
-    from: number,
-    numBlocks: number,
-    recipients: AztecAddress[],
-  ): Promise<T[]>;
+    eventFilter: PrivateEventFilter,
+  ): Promise<PrivateEvent<T>[]>;
   getChainInfo(): Promise<ChainInfo>;
   getTxReceipt(txHash: TxHash): Promise<TxReceipt>;
+  getContractMetadata(address: AztecAddress): Promise<ContractMetadata>;
+  getContractClassMetadata(id: Fr): Promise<ContractClassMetadata>;
   registerSender(address: AztecAddress, alias?: string): Promise<AztecAddress>;
   getAddressBook(): Promise<Aliased<AztecAddress>[]>;
   getAccounts(): Promise<Aliased<AztecAddress>[]>;
@@ -157,7 +213,7 @@ export type Wallet = {
   profileTx(exec: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult>;
   sendTx(exec: ExecutionPayload, opts: SendOptions): Promise<TxHash>;
   createAuthWit(from: AztecAddress, messageHashOrIntent: Fr | IntentInnerHash | CallIntent): Promise<AuthWitness>;
-  batch<const T extends readonly BatchedMethod<keyof BatchableMethods>[]>(methods: T): Promise<BatchResults<T>>;
+  batch<const T extends readonly BatchedMethod[]>(methods: T): Promise<BatchResults<T>>;
 };
 
 export const FunctionCallSchema = z.object({
@@ -226,59 +282,56 @@ export const MessageHashOrIntentSchema = z.union([
   }),
 ]);
 
-export const BatchedMethodSchema = z.union([
-  z.object({
-    name: z.literal('registerSender'),
-    args: z.tuple([schemas.AztecAddress, optional(z.string())]),
-  }),
-  z.object({
-    name: z.literal('registerContract'),
-    args: z.tuple([ContractInstanceWithAddressSchema, optional(ContractArtifactSchema), optional(schemas.Fr)]),
-  }),
-  z.object({
-    name: z.literal('sendTx'),
-    args: z.tuple([ExecutionPayloadSchema, SendOptionsSchema]),
-  }),
-  z.object({
-    name: z.literal('simulateUtility'),
-    args: z.tuple([FunctionCallSchema, optional(z.array(AuthWitness.schema))]),
-  }),
+export const EventMetadataDefinitionSchema = z.object({
+  eventSelector: schemas.EventSelector,
+  abiType: AbiTypeSchema,
+  fieldNames: z.array(z.string()),
+});
+
+export const PrivateEventSchema: z.ZodType<any> = zodFor<PrivateEvent<AbiDecoded>>()(
   z.object({
-    name: z.literal('simulateTx'),
-    args: z.tuple([ExecutionPayloadSchema, SimulateOptionsSchema]),
+    event: AbiDecodedSchema,
+    metadata: inTxSchema(),
   }),
-]);
+);
+
+export const PrivateEventFilterSchema = z.object({
+  contractAddress: schemas.AztecAddress,
+  scopes: z.array(schemas.AztecAddress),
+  txHash: optional(TxHash.schema),
+  fromBlock: optional(BlockNumberPositiveSchema),
+  toBlock: optional(BlockNumberPositiveSchema),
+});
 
 export const ContractMetadataSchema = z.object({
-  contractInstance: z.union([ContractInstanceWithAddressSchema, z.undefined()]),
+  instance: optional(ContractInstanceWithAddressSchema),
   isContractInitialized: z.boolean(),
   isContractPublished: z.boolean(),
-}) satisfies ZodFor<ContractMetadata>;
+  isContractUpdated: z.boolean(),
+  updatedContractClassId: optional(schemas.Fr),
+});
 
 export const ContractClassMetadataSchema = z.object({
-  contractClass: z.union([ContractClassWithIdSchema, z.undefined()]),
+  isArtifactRegistered: z.boolean(),
   isContractClassPubliclyRegistered: z.boolean(),
-  artifact: z.union([ContractArtifactSchema, z.undefined()]),
-}) satisfies ZodFor<ContractClassMetadata>;
-
-export const EventMetadataDefinitionSchema = z.object({
-  eventSelector: schemas.EventSelector,
-  abiType: AbiTypeSchema,
-  fieldNames: z.array(z.string()),
 });
 
-export const WalletSchema: ApiSchemaFor<Wallet> = {
+/**
+ * Record of all wallet method schemas (excluding batch).
+ * This is the single source of truth for method schemas - batch schemas are derived from this.
+ */
+const WalletMethodSchemas = {
   getChainInfo: z
     .function()
     .args()
     .returns(z.object({ chainId: schemas.Fr, version: schemas.Fr })),
-  getContractClassMetadata: z.function().args(schemas.Fr, optional(z.boolean())).returns(ContractClassMetadataSchema),
-  getContractMetadata: z.function().args(schemas.AztecAddress).returns(ContractMetadataSchema),
   getTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema),
+  getContractMetadata: z.function().args(schemas.AztecAddress).returns(ContractMetadataSchema),
+  getContractClassMetadata: z.function().args(schemas.Fr).returns(ContractClassMetadataSchema),
   getPrivateEvents: z
     .function()
-    .args(schemas.AztecAddress, EventMetadataDefinitionSchema, z.number(), z.number(), z.array(schemas.AztecAddress))
-    .returns(z.array(AbiDecodedSchema)),
+    .args(EventMetadataDefinitionSchema, PrivateEventFilterSchema)
+    .returns(z.array(PrivateEventSchema)),
   registerSender: z.function().args(schemas.AztecAddress, optional(z.string())).returns(schemas.AztecAddress),
   getAddressBook: z
     .function()
@@ -300,19 +353,46 @@ export const WalletSchema: ApiSchemaFor<Wallet> = {
   profileTx: z.function().args(ExecutionPayloadSchema, ProfileOptionsSchema).returns(TxProfileResult.schema),
   sendTx: z.function().args(ExecutionPayloadSchema, SendOptionsSchema).returns(TxHash.schema),
   createAuthWit: z.function().args(schemas.AztecAddress, MessageHashOrIntentSchema).returns(AuthWitness.schema),
+};
+
+/**
+ * Creates batch schemas from the individual wallet methods.
+ * This allows us to define them once and derive batch schemas automatically,
+ * reducing duplication and ensuring consistency.
+ */
+function createBatchSchemas<T extends Record<string, z.ZodFunction<z.ZodTuple<any, any>, z.ZodTypeAny>>>(
+  methodSchemas: T,
+) {
+  const names = Object.keys(methodSchemas) as (keyof T)[];
+
+  const namesAndArgs = names.map(name =>
+    z.object({
+      name: z.literal(name),
+      args: methodSchemas[name].parameters(),
+    }),
+  );
+
+  const namesAndReturns = names.map(name =>
+    z.object({
+      name: z.literal(name),
+      result: methodSchemas[name].returnType(),
+    }),
+  );
+
+  // Type assertion needed because discriminatedUnion expects a tuple type [T, T, ...T[]]
+  // but we're building the array dynamically. The runtime behavior is correct.
+  return {
+    input: z.discriminatedUnion('name', namesAndArgs as [(typeof namesAndArgs)[0], ...typeof namesAndArgs]),
+    output: z.discriminatedUnion('name', namesAndReturns as [(typeof namesAndReturns)[0], ...typeof namesAndReturns]),
+  };
+}
+
+const { input: BatchedMethodSchema, output: BatchedResultSchema } = createBatchSchemas(WalletMethodSchemas);
+
+export { BatchedMethodSchema, BatchedResultSchema };
+
+export const WalletSchema: ApiSchemaFor<Wallet> = {
+  ...WalletMethodSchemas,
   // @ts-expect-error - ApiSchemaFor cannot properly type generic methods with readonly arrays
-  batch: z
-    .function()
-    .args(z.array(BatchedMethodSchema))
-    .returns(
-      z.array(
-        z.discriminatedUnion('name', [
-          z.object({ name: z.literal('registerSender'), result: schemas.AztecAddress }),
-          z.object({ name: z.literal('registerContract'), result: ContractInstanceWithAddressSchema }),
-          z.object({ name: z.literal('sendTx'), result: TxHash.schema }),
-          z.object({ name: z.literal('simulateUtility'), result: UtilitySimulationResult.schema }),
-          z.object({ name: z.literal('simulateTx'), result: TxSimulationResult.schema }),
-        ]),
-      ),
-    ),
+  batch: z.function().args(z.array(BatchedMethodSchema)).returns(z.array(BatchedResultSchema)),
 };

package/dest/contract/protocol_contracts.d.ts

@@ -1,9 +0,0 @@
-import type { Wallet } from '../wallet/wallet.js';
-import { UnsafeContract } from './unsafe_contract.js';
-/** Returns a Contract wrapper for the contract class registry. */
-export declare function getClassRegistryContract(wallet: Wallet): Promise<UnsafeContract>;
-/** Returns a Contract wrapper for the contract instance registry. */
-export declare function getInstanceRegistryContract(wallet: Wallet): Promise<UnsafeContract>;
-/** Returns a Contract wrapper for the fee juice contract */
-export declare function getFeeJuice(wallet: Wallet): Promise<UnsafeContract>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdG9jb2xfY29udHJhY3RzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3QvcHJvdG9jb2xfY29udHJhY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUV0RCxrRUFBa0U7QUFDbEUsd0JBQXNCLHdCQUF3QixDQUFDLE1BQU0sRUFBRSxNQUFNLDJCQVE1RDtBQUVELHFFQUFxRTtBQUNyRSx3QkFBc0IsMkJBQTJCLENBQUMsTUFBTSxFQUFFLE1BQU0sMkJBTy9EO0FBRUQsNERBQTREO0FBQzVELHdCQUFzQixXQUFXLENBQUMsTUFBTSxFQUFFLE1BQU0sMkJBTy9DIn0=

package/dest/contract/protocol_contracts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protocol_contracts.d.ts","sourceRoot":"","sources":["../../src/contract/protocol_contracts.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,kEAAkE;AAClE,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,MAAM,2BAQ5D;AAED,qEAAqE;AACrE,wBAAsB,2BAA2B,CAAC,MAAM,EAAE,MAAM,2BAO/D;AAED,4DAA4D;AAC5D,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,2BAO/C"}

package/dest/contract/protocol_contracts.js

@@ -1,26 +0,0 @@
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { UnsafeContract } from './unsafe_contract.js';
-/** Returns a Contract wrapper for the contract class registry. */ export async function getClassRegistryContract(wallet) {
-    const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractClassRegistry);
-    if (!contractInstance) {
-        throw new Error("ContractClassRegistry is not registered in this wallet's instance");
-    }
-    const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-    return new UnsafeContract(contractInstance, artifact, wallet);
-}
-/** Returns a Contract wrapper for the contract instance registry. */ export async function getInstanceRegistryContract(wallet) {
-    const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractInstanceRegistry);
-    if (!contractInstance) {
-        throw new Error("ContractInstanceRegistry is not registered in this wallet's instance");
-    }
-    const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-    return new UnsafeContract(contractInstance, artifact, wallet);
-}
-/** Returns a Contract wrapper for the fee juice contract */ export async function getFeeJuice(wallet) {
-    const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.FeeJuice);
-    if (!contractInstance) {
-        throw new Error("FeeJuice is not registered in this wallet's instance");
-    }
-    const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-    return new UnsafeContract(contractInstance, artifact, wallet);
-}

package/dest/contract/unsafe_contract.d.ts

@@ -1,15 +0,0 @@
-import type { ContractArtifact } from '@aztec/stdlib/abi';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { Wallet } from '../wallet/wallet.js';
-import { ContractBase } from './contract_base.js';
-/** Unsafe constructor for ContractBase that bypasses the check that the instance is registered in the wallet. */
-export declare 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);
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5zYWZlX2NvbnRyYWN0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3QvdW5zYWZlX2NvbnRyYWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDMUQsT0FBTyxLQUFLLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUUxRSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbEQsaUhBQWlIO0FBQ2pILHFCQUFhLGNBQWUsU0FBUSxZQUFZO0lBQzlDO0lBQ0UsaURBQWlEO0lBQ2pELFFBQVEsRUFBRSwyQkFBMkI7SUFDckMseURBQXlEO0lBQ3pELFFBQVEsRUFBRSxnQkFBZ0I7SUFDMUIsMERBQTBEO0lBQzFELE1BQU0sRUFBRSxNQUFNLEVBR2Y7Q0FDRiJ9

package/dest/contract/unsafe_contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unsafe_contract.d.ts","sourceRoot":"","sources":["../../src/contract/unsafe_contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAE1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,iHAAiH;AACjH,qBAAa,cAAe,SAAQ,YAAY;IAC9C;IACE,iDAAiD;IACjD,QAAQ,EAAE,2BAA2B;IACrC,yDAAyD;IACzD,QAAQ,EAAE,gBAAgB;IAC1B,0DAA0D;IAC1D,MAAM,EAAE,MAAM,EAGf;CACF"}

package/dest/contract/unsafe_contract.js

@@ -1,6 +0,0 @@
-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, /** The Application Binary Interface for the contract. */ artifact, /** The wallet used for interacting with this contract. */ wallet){
-        super(instance.address, artifact, wallet);
-    }
-}

package/src/contract/protocol_contracts.ts

@@ -1,35 +0,0 @@
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-
-import type { Wallet } from '../wallet/wallet.js';
-import { UnsafeContract } from './unsafe_contract.js';
-
-/** Returns a Contract wrapper for the contract class registry. */
-export async function getClassRegistryContract(wallet: Wallet) {
-  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractClassRegistry);
-  if (!contractInstance) {
-    throw new Error("ContractClassRegistry is not registered in this wallet's instance");
-  }
-  const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-
-  return new UnsafeContract(contractInstance!, artifact!, wallet);
-}
-
-/** Returns a Contract wrapper for the contract instance registry. */
-export async function getInstanceRegistryContract(wallet: Wallet) {
-  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractInstanceRegistry);
-  if (!contractInstance) {
-    throw new Error("ContractInstanceRegistry is not registered in this wallet's instance");
-  }
-  const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-  return new UnsafeContract(contractInstance!, artifact!, wallet);
-}
-
-/** Returns a Contract wrapper for the fee juice contract */
-export async function getFeeJuice(wallet: Wallet) {
-  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.FeeJuice);
-  if (!contractInstance) {
-    throw new Error("FeeJuice is not registered in this wallet's instance");
-  }
-  const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-  return new UnsafeContract(contractInstance!, artifact!, wallet);
-}

package/src/contract/unsafe_contract.ts

@@ -1,19 +0,0 @@
-import type { ContractArtifact } from '@aztec/stdlib/abi';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-
-import type { Wallet } from '../wallet/wallet.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.address, artifact, wallet);
-  }
-}