@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/dest/hash/hash.js

@@ -1,12 +1,15 @@
-import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2Hash, poseidon2HashWithSeparator, sha256Trunc } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { GeneratorIndex, NULL_MSG_SENDER_CONTRACT_ADDRESS } from '@aztec/constants';
+import { poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { AztecAddress } from '../aztec-address/index.js';
 /**
  * Computes a hash of a given verification key.
- * @param vkBuf - The verification key as fields.
+ * @param keyAsFields - The verification key as fields.
  * @returns The hash of the verification key.
- */ export function hashVK(keyAsFields) {
-    return poseidon2Hash(keyAsFields);
+ */ export async function hashVK(keyAsFields) {
+    // Should match the implementation in barretenberg/cpp/src/barretenberg/flavor/flavor.hpp > hash()
+    return await poseidon2Hash(keyAsFields);
 }
 /**
  * Computes a note hash nonce, which will be used to create a unique note hash.
@@ -33,13 +36,12 @@ import { Fr } from '@aztec/foundation/fields';
 }
 /**
  * Computes a unique note hash.
- * @dev Includes a nonce which contains data that guarantees the resulting note hash will be unique.
- * @param nonce - A nonce (typically derived from tx hash and note hash index in the tx).
+ * @param noteNonce - The nonce that was injected into the note hash preimage in order to guarantee uniqueness.
  * @param siloedNoteHash - A siloed note hash.
  * @returns A unique note hash.
- */ export function computeUniqueNoteHash(nonce, siloedNoteHash) {
+ */ export function computeUniqueNoteHash(noteNonce, siloedNoteHash) {
     return poseidon2HashWithSeparator([
-        nonce,
+        noteNonce,
         siloedNoteHash
     ], GeneratorIndex.UNIQUE_NOTE_HASH);
 }
@@ -55,6 +57,15 @@ import { Fr } from '@aztec/foundation/fields';
         innerNullifier
     ], GeneratorIndex.OUTER_NULLIFIER);
 }
+/**
+ * Computes the protocol nullifier, which is the hash of the initial tx request siloed with the null msg sender address.
+ * @param txRequestHash - The hash of the initial tx request.
+ * @returns The siloed value of the protocol nullifier.
+ *
+ * @dev Must match the implementation in noir-protocol-circuits/crates/types/src/hash.nr > compute_protocol_nullifier
+ */ export function computeProtocolNullifier(txRequestHash) {
+    return siloNullifier(AztecAddress.fromBigInt(NULL_MSG_SENDER_CONTRACT_ADDRESS), txRequestHash);
+}
 /**
  * Computes a public data tree value ready for insertion.
  * @param value - Raw public data tree value to hash into a tree-insertion-ready value.
@@ -77,14 +88,22 @@ import { Fr } from '@aztec/foundation/fields';
 }
 /**
  * Computes the hash of a list of arguments.
+ * Used for input arguments or return values for private functions, or for authwit creation.
  * @param args - Arguments to hash.
- * @returns Pedersen hash of the arguments.
+ * @returns Hash of the arguments.
  */ export function computeVarArgsHash(args) {
     if (args.length === 0) {
         return Promise.resolve(Fr.ZERO);
     }
     return poseidon2HashWithSeparator(args, GeneratorIndex.FUNCTION_ARGS);
 }
+/**
+ * Computes the hash of a public function's calldata.
+ * @param calldata - Calldata to hash.
+ * @returns Hash of the calldata.
+ */ export function computeCalldataHash(calldata) {
+    return poseidon2HashWithSeparator(calldata, GeneratorIndex.PUBLIC_CALLDATA);
+}
 /**
  * Computes a hash of a secret.
  * @dev This function is used to generate secrets for the L1 to L2 message flow and for the TransparentNote.
@@ -105,20 +124,12 @@ export async function computeL1ToL2MessageNullifier(contract, messageHash, secre
 /**
  * Calculates a siloed hash of a scoped l2 to l1 message.
  * @returns Fr containing 248 bits of information of sha256 hash.
- */ export function siloL2ToL1Message(l2ToL1Message, version, chainId) {
-    if (l2ToL1Message.contractAddress.isZero()) {
-        return Fr.ZERO;
-    }
-    // Left-pad recipient to 32 bytes to match what the circuit is doing
-    // TODO: Only hash 20 bytes for l2l1 recipient everywhere.
-    const paddedRecipient = Buffer.alloc(32);
-    l2ToL1Message.message.recipient.toBuffer().copy(paddedRecipient, 12);
-    const preimage = Buffer.concat([
-        l2ToL1Message.contractAddress.toBuffer(),
-        version.toBuffer(),
-        paddedRecipient,
-        chainId.toBuffer(),
-        l2ToL1Message.message.content.toBuffer()
+ */ export function computeL2ToL1MessageHash({ l2Sender, l1Recipient, content, rollupVersion, chainId }) {
+    return sha256ToField([
+        l2Sender,
+        rollupVersion,
+        l1Recipient,
+        chainId,
+        content
     ]);
-    return Fr.fromBuffer(sha256Trunc(preimage));
 }

package/dest/hash/index.d.ts

@@ -1,3 +1,3 @@
 export * from './hash.js';
 export * from './map_slot.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9oYXNoL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsZUFBZSxDQUFDIn0=

package/dest/hash/map_slot.d.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 /**
  * Computes the resulting storage slot for an entry in a map.
  * @param mapSlot - The slot of the map within state.
@@ -9,4 +9,4 @@ export declare function deriveStorageSlotInMap(mapSlot: Fr | bigint, key: {
     /** Convert key to a field. */
     toField: () => Fr;
 }): Promise<Fr>;
-//# sourceMappingURL=map_slot.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwX3Nsb3QuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9oYXNoL21hcF9zbG90LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXpEOzs7OztHQUtHO0FBQ0gsd0JBQWdCLHNCQUFzQixDQUNwQyxPQUFPLEVBQUUsRUFBRSxHQUFHLE1BQU0sRUFDcEIsR0FBRyxFQUFFO0lBQ0gsOEJBQThCO0lBQzlCLE9BQU8sRUFBRSxNQUFNLEVBQUUsQ0FBQztDQUNuQixHQUNBLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FFYiJ9

package/dest/hash/map_slot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map_slot.d.ts","sourceRoot":"","sources":["../../src/hash/map_slot.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,EAAE,GAAG,MAAM,EACpB,GAAG,EAAE;IACH,8BAA8B;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,GACA,OAAO,CAAC,EAAE,CAAC,CAEb"}
+{"version":3,"file":"map_slot.d.ts","sourceRoot":"","sources":["../../src/hash/map_slot.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEzD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,EAAE,GAAG,MAAM,EACpB,GAAG,EAAE;IACH,8BAA8B;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,GACA,OAAO,CAAC,EAAE,CAAC,CAEb"}

package/dest/hash/map_slot.js

@@ -1,4 +1,4 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
 /**
  * Computes the resulting storage slot for an entry in a map.
  * @param mapSlot - The slot of the map within state.

package/dest/interfaces/allowed_element.d.ts

@@ -0,0 +1,52 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { z } from 'zod';
+import type { FunctionSelector } from '../abi/function_selector.js';
+import type { AztecAddress } from '../aztec-address/index.js';
+type AllowedInstance = {
+    address: AztecAddress;
+};
+type AllowedInstanceFunction = {
+    address: AztecAddress;
+    selector: FunctionSelector;
+};
+type AllowedClass = {
+    classId: Fr;
+};
+type AllowedClassFunction = {
+    classId: Fr;
+    selector: FunctionSelector;
+};
+export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | AllowedClassFunction;
+export declare const AllowedElementSchema: z.ZodUnion<[z.ZodObject<{
+    address: import("../schemas/index.js").ZodFor<AztecAddress>;
+    selector: import("../schemas/index.js").ZodFor<FunctionSelector>;
+}, "strip", z.ZodTypeAny, {
+    address: AztecAddress;
+    selector: FunctionSelector;
+}, {
+    address?: any;
+    selector?: any;
+}>, z.ZodObject<{
+    address: import("../schemas/index.js").ZodFor<AztecAddress>;
+}, "strip", z.ZodTypeAny, {
+    address: AztecAddress;
+}, {
+    address?: any;
+}>, z.ZodObject<{
+    classId: import("../schemas/index.js").ZodFor<Fr>;
+    selector: import("../schemas/index.js").ZodFor<FunctionSelector>;
+}, "strip", z.ZodTypeAny, {
+    classId: Fr;
+    selector: FunctionSelector;
+}, {
+    classId?: any;
+    selector?: any;
+}>, z.ZodObject<{
+    classId: import("../schemas/index.js").ZodFor<Fr>;
+}, "strip", z.ZodTypeAny, {
+    classId: Fr;
+}, {
+    classId?: any;
+}>]>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsb3dlZF9lbGVtZW50LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW50ZXJmYWNlcy9hbGxvd2VkX2VsZW1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFekQsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4QixPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ3BFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRzlELEtBQUssZUFBZSxHQUFHO0lBQUUsT0FBTyxFQUFFLFlBQVksQ0FBQTtDQUFFLENBQUM7QUFDakQsS0FBSyx1QkFBdUIsR0FBRztJQUFFLE9BQU8sRUFBRSxZQUFZLENBQUM7SUFBQyxRQUFRLEVBQUUsZ0JBQWdCLENBQUE7Q0FBRSxDQUFDO0FBQ3JGLEtBQUssWUFBWSxHQUFHO0lBQUUsT0FBTyxFQUFFLEVBQUUsQ0FBQTtDQUFFLENBQUM7QUFDcEMsS0FBSyxvQkFBb0IsR0FBRztJQUFFLE9BQU8sRUFBRSxFQUFFLENBQUM7SUFBQyxRQUFRLEVBQUUsZ0JBQWdCLENBQUE7Q0FBRSxDQUFDO0FBRXhFLE1BQU0sTUFBTSxjQUFjLEdBQUcsZUFBZSxHQUFHLHVCQUF1QixHQUFHLFlBQVksR0FBRyxvQkFBb0IsQ0FBQztBQUU3RyxlQUFPLE1BQU0sb0JBQW9COzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7SUFPaEMsQ0FBQyJ9

package/dest/interfaces/allowed_element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allowed_element.d.ts","sourceRoot":"","sources":["../../src/interfaces/allowed_element.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG9D,KAAK,eAAe,GAAG;IAAE,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC;AACjD,KAAK,uBAAuB,GAAG;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAA;CAAE,CAAC;AACrF,KAAK,YAAY,GAAG;IAAE,OAAO,EAAE,EAAE,CAAA;CAAE,CAAC;AACpC,KAAK,oBAAoB,GAAG;IAAE,OAAO,EAAE,EAAE,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAExE,MAAM,MAAM,cAAc,GAAG,eAAe,GAAG,uBAAuB,GAAG,YAAY,GAAG,oBAAoB,CAAC;AAE7G,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAOhC,CAAC"}

package/dest/interfaces/allowed_element.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { schemas, zodFor } from '../schemas/index.js';
+export const AllowedElementSchema = zodFor()(z.union([
+    z.object({
+        address: schemas.AztecAddress,
+        selector: schemas.FunctionSelector
+    }),
+    z.object({
+        address: schemas.AztecAddress
+    }),
+    z.object({
+        classId: schemas.Fr,
+        selector: schemas.FunctionSelector
+    }),
+    z.object({
+        classId: schemas.Fr
+    })
+]));

package/dest/interfaces/api_limit.d.ts

@@ -0,0 +1,5 @@
+export declare const MAX_RPC_LEN = 100;
+export declare const MAX_RPC_TXS_LEN = 50;
+export declare const MAX_RPC_BLOCKS_LEN = 50;
+export declare const MAX_RPC_CHECKPOINTS_LEN = 50;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpX2xpbWl0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW50ZXJmYWNlcy9hcGlfbGltaXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZUFBTyxNQUFNLFdBQVcsTUFBTSxDQUFDO0FBQy9CLGVBQU8sTUFBTSxlQUFlLEtBQUssQ0FBQztBQUNsQyxlQUFPLE1BQU0sa0JBQWtCLEtBQUssQ0FBQztBQUNyQyxlQUFPLE1BQU0sdUJBQXVCLEtBQUssQ0FBQyJ9

package/dest/interfaces/api_limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api_limit.d.ts","sourceRoot":"","sources":["../../src/interfaces/api_limit.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,MAAM,CAAC;AAC/B,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,uBAAuB,KAAK,CAAC"}

package/dest/interfaces/api_limit.js

@@ -0,0 +1,4 @@
+export const MAX_RPC_LEN = 100;
+export const MAX_RPC_TXS_LEN = 50;
+export const MAX_RPC_BLOCKS_LEN = 50;
+export const MAX_RPC_CHECKPOINTS_LEN = 50;

package/dest/interfaces/archiver.d.ts

@@ -1,9 +1,61 @@
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import type { ApiSchemaFor } from '@aztec/foundation/schemas';
+import { z } from 'zod';
 import { type L2BlockSource } from '../block/l2_block_source.js';
-import type { NullifierWithBlockSource } from '../block/nullifier_with_block_source.js';
 import { type ContractDataSource } from '../contract/index.js';
 import type { L1ToL2MessageSource } from '../messaging/l1_to_l2_message_source.js';
 import type { L2LogsSource } from './l2_logs_source.js';
-export type ArchiverApi = Omit<L2BlockSource & L2LogsSource & ContractDataSource & L1ToL2MessageSource & NullifierWithBlockSource, 'start' | 'stop'>;
+/**
+ * The archiver configuration.
+ */
+export type ArchiverSpecificConfig = {
+    /** The polling interval in ms for retrieving new L2 blocks and encrypted logs. */
+    archiverPollingIntervalMS?: number;
+    /** The number of L2 blocks the archiver will attempt to download at a time. */
+    archiverBatchSize?: number;
+    /** The polling interval viem uses in ms */
+    viemPollingIntervalMS?: number;
+    /** The deployed L1 contract addresses */
+    l1Contracts: L1ContractAddresses;
+    /** The max number of logs that can be obtained in 1 "getPublicLogs" call. */
+    maxLogs?: number;
+    /** The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKb. */
+    archiverStoreMapSizeKb?: number;
+    /** Maximum allowed drift in seconds between the Ethereum client and current time. */
+    maxAllowedEthClientDriftSeconds?: number;
+    /** Whether to allow starting the archiver without debug/trace method support on Ethereum hosts */
+    ethereumAllowNoDebugHosts?: boolean;
+    /** Skip validating checkpoint attestations (for testing purposes only) */
+    skipValidateCheckpointAttestations?: boolean;
+};
+export declare const ArchiverSpecificConfigSchema: z.ZodObject<{
+    archiverPollingIntervalMS: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>>;
+    archiverBatchSize: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>>;
+    viemPollingIntervalMS: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>>;
+    maxLogs: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>>;
+    archiverStoreMapSizeKb: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>>;
+    maxAllowedEthClientDriftSeconds: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>>;
+    ethereumAllowNoDebugHosts: z.ZodOptional<z.ZodBoolean>;
+    skipValidateCheckpointAttestations: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    archiverPollingIntervalMS?: number | undefined;
+    archiverBatchSize?: number | undefined;
+    viemPollingIntervalMS?: number | undefined;
+    maxLogs?: number | undefined;
+    archiverStoreMapSizeKb?: number | undefined;
+    maxAllowedEthClientDriftSeconds?: number | undefined;
+    ethereumAllowNoDebugHosts?: boolean | undefined;
+    skipValidateCheckpointAttestations?: boolean | undefined;
+}, {
+    archiverPollingIntervalMS?: string | number | bigint | undefined;
+    archiverBatchSize?: string | number | bigint | undefined;
+    viemPollingIntervalMS?: string | number | bigint | undefined;
+    maxLogs?: string | number | bigint | undefined;
+    archiverStoreMapSizeKb?: string | number | bigint | undefined;
+    maxAllowedEthClientDriftSeconds?: string | number | bigint | undefined;
+    ethereumAllowNoDebugHosts?: boolean | undefined;
+    skipValidateCheckpointAttestations?: boolean | undefined;
+}>;
+export type ArchiverApi = Omit<L2BlockSource & L2LogsSource & ContractDataSource & L1ToL2MessageSource, 'start' | 'stop'>;
 export declare const ArchiverApiSchema: ApiSchemaFor<ArchiverApi>;
-//# sourceMappingURL=archiver.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJjaGl2ZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbnRlcmZhY2VzL2FyY2hpdmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFFakYsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFOUQsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUt4QixPQUFPLEVBQUUsS0FBSyxhQUFhLEVBQWdCLE1BQU0sNkJBQTZCLENBQUM7QUFJL0UsT0FBTyxFQUVMLEtBQUssa0JBQWtCLEVBRXhCLE1BQU0sc0JBQXNCLENBQUM7QUFNOUIsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQztBQU9uRixPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV4RDs7R0FFRztBQUNILE1BQU0sTUFBTSxzQkFBc0IsR0FBRztJQUNuQyxrRkFBa0Y7SUFDbEYseUJBQXlCLENBQUMsRUFBRSxNQUFNLENBQUM7SUFFbkMsK0VBQStFO0lBQy9FLGlCQUFpQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBRTNCLDJDQUEyQztJQUMzQyxxQkFBcUIsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUUvQix5Q0FBeUM7SUFDekMsV0FBVyxFQUFFLG1CQUFtQixDQUFDO0lBRWpDLDZFQUE2RTtJQUM3RSxPQUFPLENBQUMsRUFBRSxNQUFNLENBQUM7SUFFakIscUdBQXFHO0lBQ3JHLHNCQUFzQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBRWhDLHFGQUFxRjtJQUNyRiwrQkFBK0IsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUV6QyxrR0FBa0c7SUFDbEcseUJBQXlCLENBQUMsRUFBRSxPQUFPLENBQUM7SUFFcEMsMEVBQTBFO0lBQzFFLGtDQUFrQyxDQUFDLEVBQUUsT0FBTyxDQUFDO0NBQzlDLENBQUM7QUFFRixlQUFPLE1BQU0sNEJBQTRCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7RUFTdkMsQ0FBQztBQUVILE1BQU0sTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUM1QixhQUFhLEdBQUcsWUFBWSxHQUFHLGtCQUFrQixHQUFHLG1CQUFtQixFQUN2RSxPQUFPLEdBQUcsTUFBTSxDQUNqQixDQUFDO0FBRUYsZUFBTyxNQUFNLGlCQUFpQixFQUFFLFlBQVksQ0FBQyxXQUFXLENBMkV2RCxDQUFDIn0=

package/dest/interfaces/archiver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archiver.d.ts","sourceRoot":"","sources":["../../src/interfaces/archiver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAM9D,OAAO,EAAE,KAAK,aAAa,EAAgB,MAAM,6BAA6B,CAAC;AAC/E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AACxF,OAAO,EAEL,KAAK,kBAAkB,EAGxB,MAAM,sBAAsB,CAAC;AAK9B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAOnF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,MAAM,MAAM,WAAW,GAAG,IAAI,CAC5B,aAAa,GAAG,YAAY,GAAG,kBAAkB,GAAG,mBAAmB,GAAG,wBAAwB,EAClG,OAAO,GAAG,MAAM,CACjB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAkDvD,CAAC"}
+{"version":3,"file":"archiver.d.ts","sourceRoot":"","sources":["../../src/interfaces/archiver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAEjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAE,KAAK,aAAa,EAAgB,MAAM,6BAA6B,CAAC;AAI/E,OAAO,EAEL,KAAK,kBAAkB,EAExB,MAAM,sBAAsB,CAAC;AAM9B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAOnF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,kFAAkF;IAClF,yBAAyB,CAAC,EAAE,MAAM,CAAC;IAEnC,+EAA+E;IAC/E,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B,2CAA2C;IAC3C,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B,yCAAyC;IACzC,WAAW,EAAE,mBAAmB,CAAC;IAEjC,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,qGAAqG;IACrG,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAEhC,qFAAqF;IACrF,+BAA+B,CAAC,EAAE,MAAM,CAAC;IAEzC,kGAAkG;IAClG,yBAAyB,CAAC,EAAE,OAAO,CAAC;IAEpC,0EAA0E;IAC1E,kCAAkC,CAAC,EAAE,OAAO,CAAC;CAC9C,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;EASvC,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,IAAI,CAC5B,aAAa,GAAG,YAAY,GAAG,kBAAkB,GAAG,mBAAmB,EACvE,OAAO,GAAG,MAAM,CACjB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CA2EvD,CAAC"}

package/dest/interfaces/archiver.js

@@ -1,51 +1,82 @@
+import { BlockNumberSchema, CheckpointNumberSchema, EpochNumberSchema } from '@aztec/foundation/branded-types';
 import { z } from 'zod';
-import { inBlockSchemaFor } from '../block/in_block.js';
+import { CheckpointedL2Block, PublishedL2Block } from '../block/checkpointed_l2_block.js';
 import { L2Block } from '../block/l2_block.js';
+import { L2BlockNew } from '../block/l2_block_new.js';
 import { L2TipsSchema } from '../block/l2_block_source.js';
-import { ContractClassPublicSchema, ContractInstanceWithAddressSchema, PublicFunctionSchema } from '../contract/index.js';
+import { ValidateCheckpointResultSchema } from '../block/validate_block_result.js';
+import { Checkpoint } from '../checkpoint/checkpoint.js';
+import { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
+import { ContractClassPublicSchema, ContractInstanceWithAddressSchema } from '../contract/index.js';
 import { L1RollupConstantsSchema } from '../epoch-helpers/index.js';
 import { LogFilterSchema } from '../logs/log_filter.js';
-import { PrivateLog } from '../logs/private_log.js';
+import { SiloedTag } from '../logs/siloed_tag.js';
+import { Tag } from '../logs/tag.js';
 import { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
 import { optional, schemas } from '../schemas/schemas.js';
 import { BlockHeader } from '../tx/block_header.js';
-import { TxEffect } from '../tx/tx_effect.js';
+import { indexedTxSchema } from '../tx/indexed_tx_effect.js';
 import { TxHash } from '../tx/tx_hash.js';
 import { TxReceipt } from '../tx/tx_receipt.js';
 import { GetContractClassLogsResponseSchema, GetPublicLogsResponseSchema } from './get_logs_response.js';
+export const ArchiverSpecificConfigSchema = z.object({
+    archiverPollingIntervalMS: schemas.Integer.optional(),
+    archiverBatchSize: schemas.Integer.optional(),
+    viemPollingIntervalMS: schemas.Integer.optional(),
+    maxLogs: schemas.Integer.optional(),
+    archiverStoreMapSizeKb: schemas.Integer.optional(),
+    maxAllowedEthClientDriftSeconds: schemas.Integer.optional(),
+    ethereumAllowNoDebugHosts: z.boolean().optional(),
+    skipValidateCheckpointAttestations: z.boolean().optional()
+});
 export const ArchiverApiSchema = {
     getRollupAddress: z.function().args().returns(schemas.EthAddress),
     getRegistryAddress: z.function().args().returns(schemas.EthAddress),
-    getBlockNumber: z.function().args().returns(schemas.Integer),
-    getProvenBlockNumber: z.function().args().returns(schemas.Integer),
-    getBlock: z.function().args(schemas.Integer).returns(L2Block.schema.optional()),
+    getBlockNumber: z.function().args().returns(BlockNumberSchema),
+    getProvenBlockNumber: z.function().args().returns(BlockNumberSchema),
+    getBlock: z.function().args(BlockNumberSchema).returns(L2Block.schema.optional()),
     getBlockHeader: z.function().args(z.union([
-        schemas.Integer,
+        BlockNumberSchema,
         z.literal('latest')
     ])).returns(BlockHeader.schema.optional()),
-    getBlocks: z.function().args(schemas.Integer, schemas.Integer, optional(z.boolean())).returns(z.array(L2Block.schema)),
-    getTxEffect: z.function().args(TxHash.schema).returns(inBlockSchemaFor(TxEffect.schema).optional()),
+    getCheckpointedBlock: z.function().args(BlockNumberSchema).returns(CheckpointedL2Block.schema.optional()),
+    getCheckpointedBlocks: z.function().args(BlockNumberSchema, schemas.Integer, optional(z.boolean())).returns(z.array(CheckpointedL2Block.schema)),
+    getBlocks: z.function().args(BlockNumberSchema, schemas.Integer, optional(z.boolean())).returns(z.array(L2Block.schema)),
+    getPublishedCheckpoints: z.function().args(CheckpointNumberSchema, schemas.Integer).returns(z.array(PublishedCheckpoint.schema)),
+    getPublishedBlocks: z.function().args(BlockNumberSchema, schemas.Integer, optional(z.boolean())).returns(z.array(PublishedL2Block.schema)),
+    getL2BlocksNew: z.function().args(BlockNumberSchema, schemas.Integer, optional(z.boolean())).returns(z.array(L2BlockNew.schema)),
+    getPublishedBlockByHash: z.function().args(schemas.Fr).returns(PublishedL2Block.schema.optional()),
+    getPublishedBlockByArchive: z.function().args(schemas.Fr).returns(PublishedL2Block.schema.optional()),
+    getBlockHeaderByHash: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
+    getBlockHeaderByArchive: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
+    getL2BlockNew: z.function().args(BlockNumberSchema).returns(L2BlockNew.schema.optional()),
+    getTxEffect: z.function().args(TxHash.schema).returns(indexedTxSchema().optional()),
     getSettledTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema.optional()),
-    getL2SlotNumber: z.function().args().returns(schemas.BigInt),
-    getL2EpochNumber: z.function().args().returns(schemas.BigInt),
-    getBlocksForEpoch: z.function().args(schemas.BigInt).returns(z.array(L2Block.schema)),
-    isEpochComplete: z.function().args(schemas.BigInt).returns(z.boolean()),
+    getL2SlotNumber: z.function().args().returns(schemas.SlotNumber.optional()),
+    getL2EpochNumber: z.function().args().returns(EpochNumberSchema.optional()),
+    getCheckpointsForEpoch: z.function().args(EpochNumberSchema).returns(z.array(Checkpoint.schema)),
+    getBlocksForEpoch: z.function().args(EpochNumberSchema).returns(z.array(L2Block.schema)),
+    getBlockHeadersForEpoch: z.function().args(EpochNumberSchema).returns(z.array(BlockHeader.schema)),
+    isEpochComplete: z.function().args(EpochNumberSchema).returns(z.boolean()),
     getL2Tips: z.function().args().returns(L2TipsSchema),
-    getPrivateLogs: z.function().args(z.number(), z.number()).returns(z.array(PrivateLog.schema)),
-    getLogsByTags: z.function().args(z.array(schemas.Fr)).returns(z.array(z.array(TxScopedL2Log.schema))),
-    findNullifiersIndexesWithBlock: z.function().args(z.number(), z.array(schemas.Fr)).returns(z.array(optional(inBlockSchemaFor(schemas.BigInt)))),
+    getPrivateLogsByTags: z.function().args(z.array(SiloedTag.schema)).returns(z.array(z.array(TxScopedL2Log.schema))),
+    getPublicLogsByTagsFromContract: z.function().args(schemas.AztecAddress, z.array(Tag.schema)).returns(z.array(z.array(TxScopedL2Log.schema))),
     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.BigInt)).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)),
+    registerContractFunctionSignatures: z.function().args(z.array(z.string())).returns(z.void()),
+    getL1ToL2Messages: z.function().args(CheckpointNumberSchema).returns(z.array(schemas.Fr)),
     getL1ToL2MessageIndex: z.function().args(schemas.Fr).returns(schemas.BigInt.optional()),
-    // TODO(#10007): Remove this method
-    addContractClass: z.function().args(ContractClassPublicSchema).returns(z.void()),
-    getContractFunctionName: z.function().args(schemas.AztecAddress, schemas.FunctionSelector).returns(optional(z.string())),
-    getL1Constants: z.function().args().returns(L1RollupConstantsSchema)
+    getDebugFunctionName: z.function().args(schemas.AztecAddress, schemas.FunctionSelector).returns(optional(z.string())),
+    getL1Constants: z.function().args().returns(L1RollupConstantsSchema),
+    getGenesisValues: z.function().args().returns(z.object({
+        genesisArchiveRoot: schemas.Fr
+    })),
+    getL1Timestamp: z.function().args().returns(schemas.BigInt.optional()),
+    syncImmediate: z.function().args().returns(z.void()),
+    isPendingChainInvalid: z.function().args().returns(z.boolean()),
+    getPendingChainValidationStatus: z.function().args().returns(ValidateCheckpointResultSchema)
 };