@aztec/stdlib 0.79.0 → 0.81.0

package/src/abi/contract_artifact.ts

@@ -9,6 +9,7 @@ import {
   ContractArtifactSchema,
   type ContractNote,
   type FieldLayout,
+  type FunctionAbi,
   type FunctionArtifact,
   FunctionType,
   type IntegerValue,
@@ -44,6 +45,7 @@ export function contractArtifactFromBuffer(buffer: Buffer): Promise<ContractArti
 
 /**
  * Gets nargo build output and returns a valid contract artifact instance.
+ * Does not include public bytecode, apart from the public_dispatch function.
  * @param input - Input object as generated by nargo compile.
  * @returns A valid contract artifact instance.
  */
@@ -54,6 +56,16 @@ export function loadContractArtifact(input: NoirCompiledContract): ContractArtif
   return generateContractArtifact(input);
 }
 
+/**
+ * Gets nargo build output and returns a valid contract artifact instance.
+ * Differs from loadContractArtifact() by retaining all bytecode.
+ * @param input - Input object as generated by nargo compile.
+ * @returns A valid contract artifact instance.
+ */
+export function loadContractArtifactForPublic(input: NoirCompiledContract): ContractArtifact {
+  return generateContractArtifactForPublic(input);
+}
+
 /**
  * Checks if the given input looks like a valid ContractArtifact. The check is not exhaustive,
  * and it's just meant to differentiate between nargo raw build artifacts and the ones
@@ -79,6 +91,22 @@ function isContractArtifact(input: any): input is ContractArtifact {
     if (typeof fn.functionType !== 'string') {
       return false;
     }
+    if (!retainBytecode(fn) && fn.bytecode.length) {
+      // We want to remove the bytecode of public fns (apart from the dispatch fn) to save space
+      // If the input is private-only, we don't need to use generateContractArtifact() below
+      return false;
+    }
+  }
+  if (!Array.isArray(maybeContractArtifact.nonDispatchPublicFunctions)) {
+    return false;
+  }
+  for (const fn of maybeContractArtifact.nonDispatchPublicFunctions) {
+    if (typeof fn.name !== 'string') {
+      return false;
+    }
+    if (typeof fn.functionType !== 'string') {
+      return false;
+    }
   }
   return true;
 }
@@ -103,15 +131,21 @@ function generateFunctionParameter(param: NoirCompiledContractFunctionParameter)
 type NoirCompiledContractFunction = NoirCompiledContract['functions'][number];
 
 /**
- * Generates a function build artifact.
+ * Returns true if we should retain bytecode
+ */
+export function retainBytecode(input: NoirCompiledContractFunction | FunctionArtifact): boolean {
+  const functionType =
+    (input as FunctionArtifact).functionType ?? getFunctionType(input as NoirCompiledContractFunction);
+  return functionType !== FunctionType.PUBLIC || input.name == 'public_dispatch';
+}
+
+/**
+ * Generates a function abi.
  * @param fn - Noir function entry.
  * @param contract - Parent contract.
- * @returns Function artifact.
+ * @returns Function abi.
  */
-function generateFunctionArtifact(
-  fn: NoirCompiledContractFunction,
-  contract: NoirCompiledContract,
-): Omit<FunctionArtifact, 'bytecode'> & { bytecode: string } {
+function generateFunctionAbi(fn: NoirCompiledContractFunction, contract: NoirCompiledContract): FunctionAbi {
   if (fn.custom_attributes === undefined) {
     throw new Error(
       `No custom attributes found for contract function ${fn.name}. Try rebuilding the contract with the latest nargo version.`,
@@ -156,10 +190,26 @@ function generateFunctionArtifact(
     isInitializer: fn.custom_attributes.includes(AZTEC_INITIALIZER_ATTRIBUTE),
     parameters,
     returnTypes,
-    bytecode: fn.bytecode,
-    debugSymbols: fn.debug_symbols,
     errorTypes: fn.abi.error_types,
     ...(fn.assert_messages ? { assertMessages: fn.assert_messages } : undefined),
+  };
+}
+
+/**
+ * Generates a function build artifact.
+ * @param fn - Noir function entry.
+ * @param contract - Parent contract.
+ * @returns Function artifact.
+ */
+function generateFunctionArtifact(
+  fn: NoirCompiledContractFunction,
+  contract: NoirCompiledContract,
+): Omit<FunctionArtifact, 'bytecode'> & { bytecode: string } {
+  const abi = generateFunctionAbi(fn, contract);
+  return {
+    ...abi,
+    bytecode: fn.bytecode,
+    debugSymbols: fn.debug_symbols,
     ...(fn.verification_key ? { verificationKey: fn.verification_key } : undefined),
   };
 }
@@ -274,19 +324,46 @@ function getNoteTypes(input: NoirCompiledContract) {
 
 /**
  * Given a Nargo output generates an Aztec-compatible contract artifact.
+ * Does not include public bytecode, apart from the public_dispatch function.
+ * @param compiled - Noir build output.
+ * @returns Aztec contract build artifact.
+ */
+function generateContractArtifact(contract: NoirCompiledContract): ContractArtifact {
+  try {
+    return ContractArtifactSchema.parse({
+      name: contract.name,
+      functions: contract.functions.filter(f => retainBytecode(f)).map(f => generateFunctionArtifact(f, contract)),
+      nonDispatchPublicFunctions: contract.functions
+        .filter(f => !retainBytecode(f))
+        .map(f => generateFunctionAbi(f, contract)),
+      outputs: contract.outputs,
+      storageLayout: getStorageLayout(contract),
+      notes: getNoteTypes(contract),
+      fileMap: contract.file_map,
+    });
+  } catch (err) {
+    throw new Error(`Could not generate contract artifact for ${contract.name}: ${err}`);
+  }
+}
+
+/**
+ * Given a Nargo output generates an Aztec-compatible contract artifact.
+ * Retains all public bytecode.
  * @param compiled - Noir build output.
  * @returns Aztec contract build artifact.
  */
-function generateContractArtifact(contract: NoirCompiledContract, aztecNrVersion?: string): ContractArtifact {
+function generateContractArtifactForPublic(contract: NoirCompiledContract): ContractArtifact {
   try {
     return ContractArtifactSchema.parse({
       name: contract.name,
       functions: contract.functions.map(f => generateFunctionArtifact(f, contract)),
+      nonDispatchPublicFunctions: contract.functions
+        .filter(f => !retainBytecode(f))
+        .map(f => generateFunctionAbi(f, contract)),
       outputs: contract.outputs,
       storageLayout: getStorageLayout(contract),
       notes: getNoteTypes(contract),
       fileMap: contract.file_map,
-      ...(aztecNrVersion ? { aztecNrVersion } : {}),
     });
   } catch (err) {
     throw new Error(`Could not generate contract artifact for ${contract.name}: ${err}`);

package/src/avm/avm.ts

@@ -12,25 +12,33 @@ import { AvmCircuitPublicInputs } from './avm_circuit_public_inputs.js';
 import { serializeWithMessagePack } from './message_pack.js';
 
 export class AvmEnqueuedCallHint {
-  constructor(public readonly contractAddress: AztecAddress, public readonly calldata: Fr[]) {}
+  constructor(
+    public readonly msgSender: AztecAddress,
+    public readonly contractAddress: AztecAddress,
+    public readonly calldata: Fr[],
+    public isStaticCall: boolean,
+  ) {}
 
   static get schema() {
     return z
       .object({
+        msgSender: AztecAddress.schema,
         contractAddress: AztecAddress.schema,
         calldata: schemas.Fr.array(),
+        isStaticCall: z.boolean(),
       })
-      .transform(({ contractAddress, calldata }) => new AvmEnqueuedCallHint(contractAddress, calldata));
+      .transform(
+        ({ msgSender, contractAddress, calldata, isStaticCall }) =>
+          new AvmEnqueuedCallHint(msgSender, contractAddress, calldata, isStaticCall),
+      );
   }
 }
 
 export class AvmContractClassHint {
   constructor(
     public readonly classId: Fr,
-    public readonly exists: boolean,
     public readonly artifactHash: Fr,
     public readonly privateFunctionsRoot: Fr,
-    public readonly publicBytecodeCommitment: Fr,
     public readonly packedBytecode: Buffer,
   ) {}
 
@@ -38,79 +46,70 @@ export class AvmContractClassHint {
     return z
       .object({
         classId: schemas.Fr,
-        exists: z.boolean(),
         artifactHash: schemas.Fr,
         privateFunctionsRoot: schemas.Fr,
-        publicBytecodeCommitment: schemas.Fr,
         packedBytecode: schemas.Buffer,
       })
       .transform(
-        ({ classId, exists, artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode }) =>
-          new AvmContractClassHint(
-            classId,
-            exists,
-            artifactHash,
-            privateFunctionsRoot,
-            publicBytecodeCommitment,
-            packedBytecode,
-          ),
+        ({ classId, artifactHash, privateFunctionsRoot, packedBytecode }) =>
+          new AvmContractClassHint(classId, artifactHash, privateFunctionsRoot, packedBytecode),
       );
   }
 }
 
+export class AvmBytecodeCommitmentHint {
+  constructor(public readonly classId: Fr, public readonly commitment: Fr) {}
+
+  static get schema() {
+    return z
+      .object({
+        classId: schemas.Fr,
+        commitment: schemas.Fr,
+      })
+      .transform(({ classId, commitment }) => new AvmBytecodeCommitmentHint(classId, commitment));
+  }
+}
+
 export class AvmContractInstanceHint {
   constructor(
     public readonly address: AztecAddress,
-    public readonly exists: boolean,
     public readonly salt: Fr,
     public readonly deployer: AztecAddress,
     public readonly currentContractClassId: Fr,
     public readonly originalContractClassId: Fr,
     public readonly initializationHash: Fr,
     public readonly publicKeys: PublicKeys,
-    // public readonly updateMembershipHint: AvmPublicDataReadTreeHint = AvmPublicDataReadTreeHint.empty(),
-    public readonly updateMembershipHint: AvmPublicDataReadTreeHint,
-    public readonly updatePreimage: Fr[] = [],
   ) {}
 
   static get schema() {
     return z
       .object({
         address: AztecAddress.schema,
-        exists: z.boolean(),
         salt: schemas.Fr,
         deployer: AztecAddress.schema,
         currentContractClassId: schemas.Fr,
         originalContractClassId: schemas.Fr,
         initializationHash: schemas.Fr,
         publicKeys: PublicKeys.schema,
-        updateMembershipHint: AvmPublicDataReadTreeHint.schema,
-        updatePreimage: schemas.Fr.array(),
       })
       .transform(
         ({
           address,
-          exists,
           salt,
           deployer,
           currentContractClassId,
           originalContractClassId,
           initializationHash,
           publicKeys,
-          updateMembershipHint,
-          updatePreimage,
         }) =>
           new AvmContractInstanceHint(
             address,
-            exists,
             salt,
             deployer,
             currentContractClassId,
             originalContractClassId,
             initializationHash,
             publicKeys,
-            updateMembershipHint,
-            updatePreimage,
           ),
       );
   }
@@ -213,20 +212,21 @@ export class AvmPublicDataWriteTreeHint {
 
 export class AvmExecutionHints {
   constructor(
-    public readonly enqueuedCalls: AvmEnqueuedCallHint[],
-    public readonly contractInstances: AvmContractInstanceHint[],
-    public readonly contractClasses: AvmContractClassHint[],
-    public readonly publicDataReads: AvmPublicDataReadTreeHint[],
-    public readonly publicDataWrites: AvmPublicDataWriteTreeHint[],
-    public readonly nullifierReads: AvmNullifierReadTreeHint[],
-    public readonly nullifierWrites: AvmNullifierWriteTreeHint[],
-    public readonly noteHashReads: AvmAppendTreeHint[],
-    public readonly noteHashWrites: AvmAppendTreeHint[],
-    public readonly l1ToL2MessageReads: AvmAppendTreeHint[],
+    public readonly enqueuedCalls: AvmEnqueuedCallHint[] = [],
+    public readonly contractInstances: AvmContractInstanceHint[] = [],
+    public readonly contractClasses: AvmContractClassHint[] = [],
+    public readonly bytecodeCommitments: AvmBytecodeCommitmentHint[] = [],
+    public readonly publicDataReads: AvmPublicDataReadTreeHint[] = [],
+    public readonly publicDataWrites: AvmPublicDataWriteTreeHint[] = [],
+    public readonly nullifierReads: AvmNullifierReadTreeHint[] = [],
+    public readonly nullifierWrites: AvmNullifierWriteTreeHint[] = [],
+    public readonly noteHashReads: AvmAppendTreeHint[] = [],
+    public readonly noteHashWrites: AvmAppendTreeHint[] = [],
+    public readonly l1ToL2MessageReads: AvmAppendTreeHint[] = [],
   ) {}
 
   static empty() {
-    return new AvmExecutionHints([], [], [], [], [], [], [], [], [], []);
+    return new AvmExecutionHints();
   }
 
   static get schema() {
@@ -235,6 +235,7 @@ export class AvmExecutionHints {
         enqueuedCalls: AvmEnqueuedCallHint.schema.array(),
         contractInstances: AvmContractInstanceHint.schema.array(),
         contractClasses: AvmContractClassHint.schema.array(),
+        bytecodeCommitments: AvmBytecodeCommitmentHint.schema.array(),
         publicDataReads: AvmPublicDataReadTreeHint.schema.array(),
         publicDataWrites: AvmPublicDataWriteTreeHint.schema.array(),
         nullifierReads: AvmNullifierReadTreeHint.schema.array(),
@@ -248,6 +249,7 @@ export class AvmExecutionHints {
           enqueuedCalls,
           contractInstances,
           contractClasses,
+          bytecodeCommitments,
           publicDataReads,
           publicDataWrites,
           nullifierReads,
@@ -260,6 +262,7 @@ export class AvmExecutionHints {
             enqueuedCalls,
             contractInstances,
             contractClasses,
+            bytecodeCommitments,
             publicDataReads,
             publicDataWrites,
             nullifierReads,

package/src/avm/public_data_write.ts

@@ -77,4 +77,8 @@ export class PublicDataWrite {
   isEmpty() {
     return this.leafSlot.isZero() && this.value.isZero();
   }
+
+  equals(other: PublicDataWrite): boolean {
+    return this.leafSlot.equals(other.leafSlot) && this.value.equals(other.value);
+  }
 }

package/src/block/body.ts

@@ -18,6 +18,12 @@ export class Body {
     });
   }
 
+  equals(other: Body) {
+    return (
+      this.txEffects.length === other.txEffects.length && this.txEffects.every((te, i) => te.equals(other.txEffects[i]))
+    );
+  }
+
   static get schema(): ZodFor<Body> {
     return z
       .object({

package/src/block/index.ts

@@ -6,3 +6,4 @@ export * from './body.js';
 export * from './l2_block_number.js';
 export * from './l2_block_source.js';
 export * from './block_hash.js';
+export * from './published_l2_block.js';

package/src/block/l2_block.ts

@@ -202,4 +202,8 @@ export class L2Block {
       ...logsStats,
     };
   }
+
+  equals(other: L2Block) {
+    return this.archive.equals(other.archive) && this.header.equals(other.header) && this.body.equals(other.body);
+  }
 }

package/src/block/l2_block_downloader/l2_block_stream.ts

@@ -2,8 +2,8 @@ import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 
-import type { L2Block } from '../l2_block.js';
 import type { L2BlockId, L2BlockSource, L2Tips } from '../l2_block_source.js';
+import type { PublishedL2Block } from '../published_l2_block.js';
 
 /** Creates a stream of events for new blocks, chain tips updates, and reorgs, out of polling an archiver or a node. */
 export class L2BlockStream {
@@ -11,7 +11,7 @@ export class L2BlockStream {
   private isSyncing = false;
 
   constructor(
-    private l2BlockSource: Pick<L2BlockSource, 'getBlocks' | 'getBlockHeader' | 'getL2Tips'>,
+    private l2BlockSource: Pick<L2BlockSource, 'getPublishedBlocks' | 'getBlockHeader' | 'getL2Tips'>,
     private localData: L2BlockStreamLocalDataProvider,
     private handler: L2BlockStreamEventHandler,
     private readonly log = createLogger('types:block_stream'),
@@ -84,12 +84,12 @@ export class L2BlockStream {
         const from = latestBlockNumber + 1;
         const limit = Math.min(this.opts.batchSize ?? 20, sourceTips.latest.number - from + 1);
         this.log.trace(`Requesting blocks from ${from} limit ${limit} proven=${this.opts.proven}`);
-        const blocks = await this.l2BlockSource.getBlocks(from, limit, this.opts.proven);
+        const blocks = await this.l2BlockSource.getPublishedBlocks(from, limit, this.opts.proven);
         if (blocks.length === 0) {
           break;
         }
         await this.emitEvent({ type: 'blocks-added', blocks });
-        latestBlockNumber = blocks.at(-1)!.number;
+        latestBlockNumber = blocks.at(-1)!.block.number;
       }
 
       // Update the proven and finalized tips.
@@ -160,7 +160,7 @@ export type L2BlockStreamEvent =
   | {
       type: 'blocks-added';
       /** New blocks added to the chain. */
-      blocks: L2Block[];
+      blocks: PublishedL2Block[];
     }
   | {
       type: 'chain-pruned';

package/src/block/l2_block_source.ts

@@ -10,6 +10,7 @@ import type { TxHash } from '../tx/tx_hash.js';
 import type { TxReceipt } from '../tx/tx_receipt.js';
 import type { InBlock } from './in_block.js';
 import type { L2Block } from './l2_block.js';
+import type { PublishedL2Block } from './published_l2_block.js';
 
 /**
  * Interface of classes allowing for the retrieval of L2 blocks.
@@ -62,6 +63,9 @@ export interface L2BlockSource {
    */
   getBlocks(from: number, limit: number, proven?: boolean): Promise<L2Block[]>;
 
+  /** Equivalent to getBlocks but includes publish data. */
+  getPublishedBlocks(from: number, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+
   /**
    * Gets a tx effect.
    * @param txHash - The hash of a transaction which resulted in the returned tx effect.

package/src/block/published_l2_block.ts

@@ -0,0 +1,45 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { times } from '@aztec/foundation/collection';
+import { Secp256k1Signer } from '@aztec/foundation/crypto';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { schemas } from '@aztec/foundation/schemas';
+import { L2Block } from '@aztec/stdlib/block';
+
+import { z } from 'zod';
+
+export type L1PublishedData = {
+  blockNumber: bigint;
+  timestamp: bigint;
+  blockHash: string;
+};
+
+export type PublishedL2Block = {
+  block: L2Block;
+  l1: L1PublishedData;
+  signatures: Signature[];
+};
+
+export const PublishedL2BlockSchema = z.object({
+  block: L2Block.schema,
+  l1: z.object({
+    blockNumber: schemas.BigInt,
+    timestamp: schemas.BigInt,
+    blockHash: z.string(),
+  }),
+  signatures: z.array(Signature.schema),
+});
+
+export async function randomPublishedL2Block(l2BlockNumber: number): Promise<PublishedL2Block> {
+  const block = await L2Block.random(l2BlockNumber);
+  const l1 = {
+    blockNumber: BigInt(block.number),
+    timestamp: block.header.globalVariables.timestamp.toBigInt(),
+    blockHash: Buffer32.random().toString(),
+  };
+  // Create valid signatures
+  const signers = times(3, () => Secp256k1Signer.random());
+  const signatures = await Promise.all(
+    times(3, async i => signers[i].signMessage(Buffer32.fromField(await block.hash()))),
+  );
+  return { block, l1, signatures };
+}

package/src/contract/contract_class.ts

@@ -20,6 +20,8 @@ export async function getContractClassFromArtifact(
 ): Promise<ContractClassWithId & ContractClassIdPreimage> {
   const artifactHash = 'artifactHash' in artifact ? artifact.artifactHash : await computeArtifactHash(artifact);
   const publicFunctions = artifact.functions.filter(f => f.functionType === FunctionType.PUBLIC);
+  // TODO(#8985): ContractArtifact.functions should ensure that the below only contains the public dispatch function
+  // So we can likely remove this and just use the below to assign the dispatch.
   const artifactPublicFunctions: ContractClass['publicFunctions'] = await Promise.all(
     publicFunctions.map(async f => ({
       selector: await FunctionSelector.fromNameAndParameters(f.name, f.parameters),

package/src/contract/contract_instance.ts

@@ -2,7 +2,14 @@ import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { type ContractArtifact, type FunctionArtifact, FunctionSelector, getDefaultInitializer } from '../abi/index.js';
+import {
+  type ContractArtifact,
+  type FunctionAbi,
+  type FunctionArtifact,
+  FunctionSelector,
+  getAllFunctionAbis,
+  getDefaultInitializer,
+} from '../abi/index.js';
 import { AztecAddress } from '../aztec-address/index.js';
 import { getContractClassFromArtifact } from '../contract/contract_class.js';
 import { PublicKeys } from '../keys/public_keys.js';
@@ -101,7 +108,7 @@ export class SerializableContractInstance {
 export async function getContractInstanceFromDeployParams(
   artifact: ContractArtifact,
   opts: {
-    constructorArtifact?: FunctionArtifact | string;
+    constructorArtifact?: FunctionAbi | string;
     constructorArgs?: any[];
     skipArgsDecoding?: boolean;
     salt?: Fr;
@@ -138,14 +145,15 @@ export async function getContractInstanceFromDeployParams(
 
 function getConstructorArtifact(
   artifact: ContractArtifact,
-  requestedConstructorArtifact: FunctionArtifact | string | undefined,
-): FunctionArtifact | undefined {
+  requestedConstructorArtifact: FunctionArtifact | FunctionAbi | string | undefined,
+): FunctionAbi | undefined {
   if (typeof requestedConstructorArtifact === 'string') {
-    const found = artifact.functions.find(fn => fn.name === requestedConstructorArtifact);
+    const found = getAllFunctionAbis(artifact).find(fn => fn.name === requestedConstructorArtifact);
     if (!found) {
       throw new Error(`No constructor found with name ${requestedConstructorArtifact}`);
     }
     return found;
   }
+  // TODO: shouldn't we check that requestedConstructorArtifact exists on artifact before returning?
   return requestedConstructorArtifact ?? getDefaultInitializer(artifact);
 }

package/src/contract/interfaces/contract_data_source.ts

@@ -2,18 +2,10 @@ import type { Fr } from '@aztec/foundation/fields';
 
 import { FunctionSelector } from '../../abi/index.js';
 import type { AztecAddress } from '../../aztec-address/index.js';
-import type { ContractClassPublic, PublicFunction } from './contract_class.js';
+import type { ContractClassPublic } from './contract_class.js';
 import type { ContractInstanceWithAddress } from './contract_instance.js';
 
 export interface ContractDataSource {
-  /**
-   * Returns a contract's encoded public function, given its function selector.
-   * @param address - The contract aztec address.
-   * @param selector - The function's selector.
-   * @returns The function's data.
-   */
-  getPublicFunction(address: AztecAddress, selector: FunctionSelector): Promise<PublicFunction | undefined>;
-
   /**
    * Gets the number of the latest L2 block processed by the implementation.
    * @returns The number of the latest L2 block processed by the implementation.
@@ -37,8 +29,9 @@ export interface ContractDataSource {
   /**
    * Returns a publicly deployed contract instance given its address.
    * @param address - Address of the deployed contract.
+   * @param blockNumber - Block number at which to retrieve the contract instance. If not provided, the latest block should be used.
    */
-  getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
+  getContract(address: AztecAddress, blockNumber?: number): Promise<ContractInstanceWithAddress | undefined>;
 
   /**
    * Returns the list of all class ids known.

package/src/database-version/version_manager.ts

@@ -148,7 +148,7 @@ export class DatabaseVersionManager<T> {
         }
       } else if (cmp !== 0) {
         this.log.info(
-          `Can't upgrade from version ${storedVersion.schemaVersion} to ${this.currentVersion}. Resetting database at ${this.dataDirectory}`,
+          `Can't upgrade from version ${storedVersion.schemaVersion} to ${this.currentVersion.schemaVersion}. Resetting database at ${this.dataDirectory}`,
         );
         needsReset = true;
       }

package/src/interfaces/archiver.ts

@@ -6,11 +6,11 @@ import { inBlockSchemaFor } from '../block/in_block.js';
 import { L2Block } from '../block/l2_block.js';
 import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
 import type { NullifierWithBlockSource } from '../block/nullifier_with_block_source.js';
+import { PublishedL2BlockSchema } from '../block/published_l2_block.js';
 import {
   ContractClassPublicSchema,
   type ContractDataSource,
   ContractInstanceWithAddressSchema,
-  PublicFunctionSchema,
 } from '../contract/index.js';
 import { L1RollupConstantsSchema } from '../epoch-helpers/index.js';
 import { LogFilterSchema } from '../logs/log_filter.js';
@@ -44,6 +44,10 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
     .function()
     .args(schemas.Integer, schemas.Integer, optional(z.boolean()))
     .returns(z.array(L2Block.schema)),
+  getPublishedBlocks: z
+    .function()
+    .args(schemas.Integer, schemas.Integer, optional(z.boolean()))
+    .returns(z.array(PublishedL2BlockSchema)),
   getTxEffect: z.function().args(TxHash.schema).returns(inBlockSchemaFor(TxEffect.schema).optional()),
   getSettledTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema.optional()),
   getL2SlotNumber: z.function().args().returns(schemas.BigInt),
@@ -62,13 +66,12 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
     .returns(z.array(optional(inBlockSchemaFor(schemas.BigInt)))),
   getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
   getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
-  getPublicFunction: z
-    .function()
-    .args(schemas.AztecAddress, schemas.FunctionSelector)
-    .returns(PublicFunctionSchema.optional()),
   getContractClass: z.function().args(schemas.Fr).returns(ContractClassPublicSchema.optional()),
   getBytecodeCommitment: z.function().args(schemas.Fr).returns(schemas.Fr),
-  getContract: z.function().args(schemas.AztecAddress).returns(ContractInstanceWithAddressSchema.optional()),
+  getContract: z
+    .function()
+    .args(schemas.AztecAddress, optional(schemas.Integer))
+    .returns(ContractInstanceWithAddressSchema.optional()),
   getContractClassIds: z.function().args().returns(z.array(schemas.Fr)),
   registerContractFunctionSignatures: z.function().args(schemas.AztecAddress, z.array(z.string())).returns(z.void()),
   getL1ToL2Messages: z.function().args(schemas.BigInt).returns(z.array(schemas.Fr)),

package/src/interfaces/aztec-node.ts

@@ -17,6 +17,7 @@ import { type InBlock, inBlockSchemaFor } from '../block/in_block.js';
 import { L2Block } from '../block/l2_block.js';
 import { type L2BlockNumber, L2BlockNumberSchema } from '../block/l2_block_number.js';
 import { type L2BlockSource, type L2Tips, L2TipsSchema } from '../block/l2_block_source.js';
+import { PublishedL2BlockSchema } from '../block/published_l2_block.js';
 import {
   type ContractClassPublic,
   ContractClassPublicSchema,
@@ -63,7 +64,7 @@ import { type WorldStateSyncStatus, WorldStateSyncStatusSchema } from './world_s
  */
 export interface AztecNode
   extends ProverCoordination,
-    Pick<L2BlockSource, 'getBlocks' | 'getBlockHeader' | 'getL2Tips'> {
+    Pick<L2BlockSource, 'getBlocks' | 'getPublishedBlocks' | 'getBlockHeader' | 'getL2Tips'> {
   /**
    * Returns the tips of the L2 chain.
    */
@@ -534,6 +535,8 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 
   getBlocks: z.function().args(z.number(), z.number()).returns(z.array(L2Block.schema)),
 
+  getPublishedBlocks: z.function().args(z.number(), z.number()).returns(z.array(PublishedL2BlockSchema)),
+
   getCurrentBaseFees: z.function().returns(GasFees.schema),
 
   getNodeVersion: z.function().returns(z.string()),