@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.017a351

package/dest/block/l2_block_downloader/index.d.ts

@@ -1,3 +0,0 @@
-export * from './l2_block_downloader.js';
-export * from './l2_block_stream.js';
-//# sourceMappingURL=index.d.ts.map

package/dest/block/l2_block_downloader/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/block/l2_block_downloader/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC"}

package/dest/block/l2_block_downloader/index.js

@@ -1,2 +0,0 @@
-export * from './l2_block_downloader.js';
-export * from './l2_block_stream.js';

package/dest/block/l2_block_downloader/l2_block_downloader.d.ts

@@ -1,58 +0,0 @@
-import type { L2Block } from '../l2_block.js';
-import type { L2BlockSource } from '../l2_block_source.js';
-/**
- * Downloads L2 blocks from a L2BlockSource.
- * The blocks are stored in a queue and can be retrieved using the getBlocks method.
- * The queue size is limited by the maxQueueSize parameter.
- * The downloader will pause when the queue is full or when the L2BlockSource is out of blocks.
- */
-export declare class L2BlockDownloader {
-    private l2BlockSource;
-    private runningPromise?;
-    private running;
-    private from;
-    private interruptibleSleep;
-    private readonly semaphore;
-    private readonly jobQueue;
-    private readonly blockQueue;
-    private readonly proven;
-    private readonly pollIntervalMS;
-    constructor(l2BlockSource: L2BlockSource, opts: {
-        maxQueueSize: number;
-        proven?: boolean;
-        pollIntervalMS?: number;
-    });
-    /**
-     * Starts the downloader.
-     * @param from - The block number to start downloading from. Defaults to INITIAL_L2_BLOCK_NUM.
-     */
-    start(from?: number): void;
-    /**
-     * Repeatedly queries the block source and adds the received blocks to the block queue.
-     * Stops when no further blocks are received.
-     * @param targetBlockNumber - Optional block number to stop at.
-     * @param proven - Optional override of the default "proven" setting.
-     * @returns The total number of blocks added to the block queue.
-     */
-    private collectBlocks;
-    /**
-     * Stops the downloader.
-     */
-    stop(): Promise<void>;
-    /**
-     * Gets the next batch of blocks from the queue.
-     * @param timeout - optional timeout value to prevent permanent blocking
-     * @returns The next batch of blocks from the queue.
-     */
-    getBlocks(timeout?: number): Promise<L2Block[]>;
-    /**
-     * Forces an immediate request for blocks.
-     * Repeatedly queries the block source and adds the received blocks to the block queue.
-     * Stops when no further blocks are received.
-     * @param targetBlockNumber - Optional block number to stop at.
-     * @param proven - Optional override of the default "proven" setting.
-     * @returns A promise that fulfills once the poll is complete
-     */
-    pollImmediate(targetBlockNumber?: number, onlyProven?: boolean): Promise<number>;
-}
-//# sourceMappingURL=l2_block_downloader.d.ts.map

package/dest/block/l2_block_downloader/l2_block_downloader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"l2_block_downloader.d.ts","sourceRoot":"","sources":["../../../src/block/l2_block_downloader/l2_block_downloader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAI3D;;;;;GAKG;AACH,qBAAa,iBAAiB;IAY1B,OAAO,CAAC,aAAa;IAXvB,OAAO,CAAC,cAAc,CAAC,CAAgB;IACvC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,kBAAkB,CAA4B;IACtD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoC;IAC/D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;gBAG9B,aAAa,EAAE,aAAa,EACpC,IAAI,EAAE;QACJ,YAAY,EAAE,MAAM,CAAC;QACrB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;IAOH;;;OAGG;IACI,KAAK,CAAC,IAAI,SAAuB;IAuBxC;;;;;;OAMG;YACW,aAAa;IAiC3B;;OAEG;IACU,IAAI;IAQjB;;;;OAIG;IACU,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAc5D;;;;;;;OAOG;IACI,aAAa,CAAC,iBAAiB,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;CAGxF"}

package/dest/block/l2_block_downloader/l2_block_downloader.js

@@ -1,124 +0,0 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { createLogger } from '@aztec/foundation/log';
-import { FifoMemoryQueue, Semaphore, SerialQueue } from '@aztec/foundation/queue';
-import { InterruptibleSleep } from '@aztec/foundation/sleep';
-const log = createLogger('types:l2_block_downloader');
-/**
- * Downloads L2 blocks from a L2BlockSource.
- * The blocks are stored in a queue and can be retrieved using the getBlocks method.
- * The queue size is limited by the maxQueueSize parameter.
- * The downloader will pause when the queue is full or when the L2BlockSource is out of blocks.
- */ export class L2BlockDownloader {
-    l2BlockSource;
-    runningPromise;
-    running;
-    from;
-    interruptibleSleep;
-    semaphore;
-    jobQueue;
-    blockQueue;
-    proven;
-    pollIntervalMS;
-    constructor(l2BlockSource, opts){
-        this.l2BlockSource = l2BlockSource;
-        this.running = false;
-        this.from = 0;
-        this.interruptibleSleep = new InterruptibleSleep();
-        this.jobQueue = new SerialQueue();
-        this.blockQueue = new FifoMemoryQueue();
-        this.pollIntervalMS = opts.pollIntervalMS ?? 1000;
-        this.proven = opts.proven ?? false;
-        this.semaphore = new Semaphore(opts.maxQueueSize);
-    }
-    /**
-   * Starts the downloader.
-   * @param from - The block number to start downloading from. Defaults to INITIAL_L2_BLOCK_NUM.
-   */ start(from = INITIAL_L2_BLOCK_NUM) {
-        if (this.running) {
-            this.interruptibleSleep.interrupt();
-            return;
-        }
-        this.from = from;
-        this.running = true;
-        const fn = async ()=>{
-            while(this.running){
-                try {
-                    await this.jobQueue.put(()=>this.collectBlocks());
-                    await this.interruptibleSleep.sleep(this.pollIntervalMS);
-                } catch (err) {
-                    log.error(`Error downloading L2 block`, err);
-                    await this.interruptibleSleep.sleep(this.pollIntervalMS);
-                }
-            }
-        };
-        this.jobQueue.start();
-        this.runningPromise = fn();
-    }
-    /**
-   * Repeatedly queries the block source and adds the received blocks to the block queue.
-   * Stops when no further blocks are received.
-   * @param targetBlockNumber - Optional block number to stop at.
-   * @param proven - Optional override of the default "proven" setting.
-   * @returns The total number of blocks added to the block queue.
-   */ async collectBlocks(targetBlockNumber, onlyProven) {
-        let totalBlocks = 0;
-        while(true){
-            // If we have a target and have reached it, return
-            if (targetBlockNumber !== undefined && this.from > targetBlockNumber) {
-                log.verbose(`Reached target block number ${targetBlockNumber}`);
-                return totalBlocks;
-            }
-            // If we have a target, then request at most the number of blocks to get to it
-            const limit = targetBlockNumber !== undefined ? Math.min(targetBlockNumber - this.from + 1, 10) : 10;
-            const proven = onlyProven === undefined ? this.proven : onlyProven;
-            // Hit the archiver for blocks
-            const blocks = await this.l2BlockSource.getBlocks(this.from, limit, proven);
-            // If there are no more blocks, return
-            if (!blocks.length) {
-                return totalBlocks;
-            }
-            log.verbose(`Received ${blocks.length} blocks from archiver after querying from ${this.from} limit ${limit} (proven ${proven})`);
-            // Push new blocks into the queue and loop
-            await this.semaphore.acquire();
-            this.blockQueue.put(blocks);
-            this.from += blocks.length;
-            totalBlocks += blocks.length;
-        }
-    }
-    /**
-   * Stops the downloader.
-   */ async stop() {
-        this.running = false;
-        this.interruptibleSleep.interrupt();
-        await this.jobQueue.cancel();
-        this.blockQueue.cancel();
-        await this.runningPromise;
-    }
-    /**
-   * Gets the next batch of blocks from the queue.
-   * @param timeout - optional timeout value to prevent permanent blocking
-   * @returns The next batch of blocks from the queue.
-   */ async getBlocks(timeout) {
-        try {
-            const blocks = await this.blockQueue.get(timeout);
-            if (!blocks) {
-                return [];
-            }
-            this.semaphore.release();
-            return blocks;
-        } catch (err) {
-            // nothing to do
-            return [];
-        }
-    }
-    /**
-   * Forces an immediate request for blocks.
-   * Repeatedly queries the block source and adds the received blocks to the block queue.
-   * Stops when no further blocks are received.
-   * @param targetBlockNumber - Optional block number to stop at.
-   * @param proven - Optional override of the default "proven" setting.
-   * @returns A promise that fulfills once the poll is complete
-   */ pollImmediate(targetBlockNumber, onlyProven) {
-        return this.jobQueue.put(()=>this.collectBlocks(targetBlockNumber, onlyProven));
-    }
-}

package/dest/block/l2_block_downloader/l2_block_stream.d.ts

@@ -1,57 +0,0 @@
-import type { L2Block } from '../l2_block.js';
-import type { L2BlockSource, L2Tips } from '../l2_block_source.js';
-/** Creates a stream of events for new blocks, chain tips updates, and reorgs, out of polling an archiver or a node. */
-export declare class L2BlockStream {
-    private l2BlockSource;
-    private localData;
-    private handler;
-    private readonly log;
-    private opts;
-    private readonly runningPromise;
-    private isSyncing;
-    constructor(l2BlockSource: Pick<L2BlockSource, 'getBlocks' | 'getBlockHeader' | 'getL2Tips'>, localData: L2BlockStreamLocalDataProvider, handler: L2BlockStreamEventHandler, log?: import("@aztec/foundation/log").Logger, opts?: {
-        proven?: boolean;
-        pollIntervalMS?: number;
-        batchSize?: number;
-        startingBlock?: number;
-    });
-    start(): void;
-    stop(): Promise<void>;
-    isRunning(): boolean;
-    sync(): Promise<void>;
-    protected work(): Promise<void>;
-    /**
-     * Returns whether the source and local agree on the block hash at a given height.
-     * @param blockNumber - The block number to test.
-     * @param args - A cache of data already requested from source, to avoid re-requesting it.
-     */
-    private areBlockHashesEqualAt;
-    private emitEvent;
-}
-/** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
-export interface L2BlockStreamLocalDataProvider {
-    getL2BlockHash(number: number): Promise<string | undefined>;
-    getL2Tips(): Promise<L2Tips>;
-}
-/** Interface to a handler of events emitted. */
-export interface L2BlockStreamEventHandler {
-    handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
-}
-export type L2BlockStreamEvent = {
-    type: 'blocks-added';
-    /** New blocks added to the chain. */
-    blocks: L2Block[];
-} | {
-    type: 'chain-pruned';
-    /** Last correct block number (new tip of the unproven chain). */
-    blockNumber: number;
-} | {
-    type: 'chain-proven';
-    /** New proven block number */
-    blockNumber: number;
-} | {
-    type: 'chain-finalized';
-    /** New finalized block number */
-    blockNumber: number;
-};
-//# sourceMappingURL=l2_block_stream.d.ts.map

package/dest/block/l2_block_downloader/l2_block_stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"l2_block_stream.d.ts","sourceRoot":"","sources":["../../../src/block/l2_block_downloader/l2_block_stream.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAa,aAAa,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE9E,uHAAuH;AACvH,qBAAa,aAAa;IAKtB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,IAAI;IARd,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,SAAS,CAAS;gBAGhB,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,WAAW,GAAG,gBAAgB,GAAG,WAAW,CAAC,EAChF,SAAS,EAAE,8BAA8B,EACzC,OAAO,EAAE,yBAAyB,EACzB,GAAG,yCAAqC,EACjD,IAAI,GAAE;QACZ,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;KACnB;IAKD,KAAK;IAKC,IAAI;IAIV,SAAS;IAIH,IAAI;cAMD,IAAI;IAiEpB;;;;OAIG;YACW,qBAAqB;YAoBrB,SAAS;CASxB;AAED,8FAA8F;AAC9F,MAAM,WAAW,8BAA8B;IAC7C,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC5D,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CAC9B;AAED,gDAAgD;AAChD,MAAM,WAAW,yBAAyB;IACxC,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClE;AAED,MAAM,MAAM,kBAAkB,GAC1B;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,qCAAqC;IACrC,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB,GACD;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,iEAAiE;IACjE,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,8BAA8B;IAC9B,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IACE,IAAI,EAAE,iBAAiB,CAAC;IACxB,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC"}

package/dest/block/l2_block_downloader/l2_block_stream.js

@@ -1,137 +0,0 @@
-import { AbortError } from '@aztec/foundation/error';
-import { createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/running-promise';
-/** Creates a stream of events for new blocks, chain tips updates, and reorgs, out of polling an archiver or a node. */ export class L2BlockStream {
-    l2BlockSource;
-    localData;
-    handler;
-    log;
-    opts;
-    runningPromise;
-    isSyncing;
-    constructor(l2BlockSource, localData, handler, log = createLogger('types:block_stream'), opts = {}){
-        this.l2BlockSource = l2BlockSource;
-        this.localData = localData;
-        this.handler = handler;
-        this.log = log;
-        this.opts = opts;
-        this.isSyncing = false;
-        this.runningPromise = new RunningPromise(()=>this.work(), log, this.opts.pollIntervalMS ?? 1000);
-    }
-    start() {
-        this.log.verbose(`Starting L2 block stream`, this.opts);
-        this.runningPromise.start();
-    }
-    async stop() {
-        await this.runningPromise.stop();
-    }
-    isRunning() {
-        return this.runningPromise.isRunning();
-    }
-    async sync() {
-        this.isSyncing = true;
-        await this.runningPromise.trigger();
-        this.isSyncing = false;
-    }
-    async work() {
-        try {
-            const sourceTips = await this.l2BlockSource.getL2Tips();
-            const localTips = await this.localData.getL2Tips();
-            this.log.trace(`Running L2 block stream`, {
-                sourceLatest: sourceTips.latest.number,
-                localLatest: localTips.latest.number,
-                sourceFinalized: sourceTips.finalized.number,
-                localFinalized: localTips.finalized.number,
-                sourceProven: sourceTips.proven.number,
-                localProven: localTips.proven.number,
-                sourceLatestHash: sourceTips.latest.hash,
-                localLatestHash: localTips.latest.hash,
-                sourceProvenHash: sourceTips.proven.hash,
-                localProvenHash: localTips.proven.hash,
-                sourceFinalizedHash: sourceTips.finalized.hash,
-                localFinalizedHash: localTips.finalized.hash
-            });
-            // Check if there was a reorg and emit a chain-pruned event if so.
-            let latestBlockNumber = localTips.latest.number;
-            while(!await this.areBlockHashesEqualAt(latestBlockNumber, {
-                sourceCache: [
-                    sourceTips.latest
-                ]
-            })){
-                latestBlockNumber--;
-            }
-            if (latestBlockNumber < localTips.latest.number) {
-                this.log.verbose(`Reorg detected. Pruning blocks from ${latestBlockNumber + 1} to ${localTips.latest.number}.`);
-                await this.emitEvent({
-                    type: 'chain-pruned',
-                    blockNumber: latestBlockNumber
-                });
-            }
-            // If we are just starting, use the starting block number from the options.
-            if (latestBlockNumber === 0 && this.opts.startingBlock !== undefined) {
-                latestBlockNumber = Math.max(this.opts.startingBlock - 1, 0);
-                this.log.verbose(`Starting sync from block number ${latestBlockNumber}`);
-            }
-            // Request new blocks from the source.
-            while(latestBlockNumber < sourceTips.latest.number){
-                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);
-                if (blocks.length === 0) {
-                    break;
-                }
-                await this.emitEvent({
-                    type: 'blocks-added',
-                    blocks
-                });
-                latestBlockNumber = blocks.at(-1).number;
-            }
-            // Update the proven and finalized tips.
-            // TODO(palla/reorg): Should we emit this before passing the new blocks? This would allow world-state to skip
-            // building the data structures for the pending chain if it's unneeded.
-            if (localTips.proven !== undefined && sourceTips.proven.number !== localTips.proven.number) {
-                await this.emitEvent({
-                    type: 'chain-proven',
-                    blockNumber: sourceTips.proven.number
-                });
-            }
-            if (localTips.finalized !== undefined && sourceTips.finalized.number !== localTips.finalized.number) {
-                await this.emitEvent({
-                    type: 'chain-finalized',
-                    blockNumber: sourceTips.finalized.number
-                });
-            }
-        } catch (err) {
-            if (err.name === 'AbortError') {
-                return;
-            }
-            this.log.error(`Error processing block stream`, err);
-        }
-    }
-    /**
-   * Returns whether the source and local agree on the block hash at a given height.
-   * @param blockNumber - The block number to test.
-   * @param args - A cache of data already requested from source, to avoid re-requesting it.
-   */ async areBlockHashesEqualAt(blockNumber, args) {
-        if (blockNumber === 0) {
-            return true;
-        }
-        const localBlockHash = await this.localData.getL2BlockHash(blockNumber);
-        const sourceBlockHash = args.sourceCache.find((id)=>id.number === blockNumber && id.hash)?.hash ?? await this.l2BlockSource.getBlockHeader(blockNumber).then((h)=>h?.hash()).then((hash)=>hash?.toString());
-        this.log.trace(`Comparing block hashes for block ${blockNumber}`, {
-            localBlockHash,
-            sourceBlockHash,
-            sourceCacheNumber: args.sourceCache[0]?.number,
-            sourceCacheHash: args.sourceCache[0]?.hash
-        });
-        return localBlockHash === sourceBlockHash;
-    }
-    async emitEvent(event) {
-        this.log.debug(`Emitting ${event.type} (${event.type === 'blocks-added' ? event.blocks.length : event.blockNumber})`);
-        await this.handler.handleBlockStreamEvent(event);
-        if (!this.isRunning() && !this.isSyncing) {
-            throw new AbortError();
-        }
-    }
-}

package/dest/block/l2_block_number.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-export declare const L2BlockNumberSchema: z.ZodUnion<[z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>, z.ZodLiteral<"latest">]>;
-/** Helper type for a specific L2 block number or the latest block number */
-export type L2BlockNumber = z.infer<typeof L2BlockNumberSchema>;
-//# sourceMappingURL=l2_block_number.d.ts.map

package/dest/block/l2_block_number.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"l2_block_number.d.ts","sourceRoot":"","sources":["../../src/block/l2_block_number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,mBAAmB,uHAAkD,CAAC;AAEnF,4EAA4E;AAC5E,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dest/block/l2_block_number.js

@@ -1,6 +0,0 @@
-import { z } from 'zod';
-import { schemas } from '../schemas/index.js';
-export const L2BlockNumberSchema = z.union([
-    schemas.Integer,
-    z.literal('latest')
-]);

package/dest/block/nullifier_with_block_source.d.ts

@@ -1,6 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { InBlock } from './in_block.js';
-export interface NullifierWithBlockSource {
-    findNullifiersIndexesWithBlock(blockNumber: number, nullifiers: Fr[]): Promise<(InBlock<bigint> | undefined)[]>;
-}
-//# sourceMappingURL=nullifier_with_block_source.d.ts.map

package/dest/block/nullifier_with_block_source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nullifier_with_block_source.d.ts","sourceRoot":"","sources":["../../src/block/nullifier_with_block_source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,MAAM,WAAW,wBAAwB;IACvC,8BAA8B,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC;CACjH"}

package/dest/config/config.d.ts

@@ -1,18 +0,0 @@
-import { type ConfigMappingsType } from '@aztec/foundation/config';
-import { EthAddress } from '@aztec/foundation/eth-address';
-export { type AllowedElement, type SequencerConfig, SequencerConfigSchema } from '../interfaces/configs.js';
-export declare const emptyChainConfig: ChainConfig;
-export declare const chainConfigMappings: ConfigMappingsType<ChainConfig>;
-/** Chain configuration. */
-export type ChainConfig = {
-    /** The chain id of the ethereum host. */
-    l1ChainId: number;
-    /** The version of the rollup. */
-    version: number;
-    /** The address to the L1 contracts. */
-    l1Contracts: {
-        /** The address to rollup */
-        rollupAddress: EthAddress;
-    };
-};
-//# sourceMappingURL=config.d.ts.map

package/dest/config/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,0BAA0B,CAAC;AACvF,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAE5G,eAAO,MAAM,gBAAgB,EAAE,WAI9B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,kBAAkB,CAAC,WAAW,CAgB/D,CAAC;AAEF,2BAA2B;AAC3B,MAAM,MAAM,WAAW,GAAG;IACxB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,WAAW,EAAE;QACX,4BAA4B;QAC5B,aAAa,EAAE,UAAU,CAAC;KAC3B,CAAC;CACH,CAAC"}

package/dest/config/config.js

@@ -1,28 +0,0 @@
-import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
-import { numberConfigHelper } from '@aztec/foundation/config';
-import { EthAddress } from '@aztec/foundation/eth-address';
-export { SequencerConfigSchema } from '../interfaces/configs.js';
-export const emptyChainConfig = {
-    l1ChainId: 0,
-    l1Contracts: {
-        rollupAddress: EthAddress.ZERO
-    },
-    version: 0
-};
-export const chainConfigMappings = {
-    l1ChainId: {
-        env: 'L1_CHAIN_ID',
-        parseEnv: (val)=>+val,
-        defaultValue: 31337,
-        description: 'The chain ID of the ethereum host.'
-    },
-    version: {
-        env: 'VERSION',
-        description: 'The version of the rollup.',
-        ...numberConfigHelper(1)
-    },
-    l1Contracts: {
-        description: 'The deployed L1 contract addresses',
-        nested: l1ContractAddressesMapping
-    }
-};

package/dest/contract/private_function_membership_proof.d.ts

@@ -1,32 +0,0 @@
-import { type ContractArtifact, FunctionSelector } from '../abi/index.js';
-import type { ContractClassPublic, ExecutablePrivateFunctionWithMembershipProof, PrivateFunctionMembershipProof } from './interfaces/index.js';
-/**
- * Creates a membership proof for a private function in a contract class, to be verified via `isValidPrivateFunctionMembershipProof`.
- * @param selector - Selector of the function to create the proof for.
- * @param artifact - Artifact of the contract class where the function is defined.
- */
-export declare function createPrivateFunctionMembershipProof(selector: FunctionSelector, artifact: ContractArtifact): Promise<PrivateFunctionMembershipProof>;
-/**
- * Verifies that a private function with a membership proof as emitted by the ClassRegisterer contract is valid,
- * as defined in the protocol specs at contract-deployment/classes:
- *
- * ```
- * // Load contract class from local db
- * contract_class = db.get_contract_class(contract_class_id)
- *
- * // Compute function leaf and assert it belongs to the private functions tree
- * function_leaf = pedersen([selector as Field, vk_hash], GENERATOR__FUNCTION_LEAF)
- * computed_private_function_tree_root = compute_root(function_leaf, private_function_tree_sibling_path)
- * assert computed_private_function_tree_root == contract_class.private_function_root
- *
- * // Compute artifact leaf and assert it belongs to the artifact
- * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
- * computed_artifact_private_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path)
- * computed_artifact_hash = sha256(computed_artifact_private_function_tree_root, unconstrained_functions_artifact_tree_root, artifact_metadata_hash)
- * assert computed_artifact_hash == contract_class.artifact_hash
- * ```
- * @param fn - Function to check membership proof for.
- * @param contractClass - In which contract class the function is expected to be.
- */
-export declare function isValidPrivateFunctionMembershipProof(fn: ExecutablePrivateFunctionWithMembershipProof, contractClass: Pick<ContractClassPublic, 'privateFunctionsRoot' | 'artifactHash'>): Promise<boolean>;
-//# sourceMappingURL=private_function_membership_proof.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"private_function_membership_proof.d.ts","sourceRoot":"","sources":["../../src/contract/private_function_membership_proof.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AAUxF,OAAO,KAAK,EACV,mBAAmB,EACnB,4CAA4C,EAC5C,8BAA8B,EAC/B,MAAM,uBAAuB,CAAC;AAG/B;;;;GAIG;AACH,wBAAsB,oCAAoC,CACxD,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,8BAA8B,CAAC,CA4DzC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,qCAAqC,CACzD,EAAE,EAAE,4CAA4C,EAChD,aAAa,EAAE,IAAI,CAAC,mBAAmB,EAAE,sBAAsB,GAAG,cAAc,CAAC,oBAkDlF"}

package/dest/contract/private_function_membership_proof.js

@@ -1,124 +0,0 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
-import { FunctionSelector, FunctionType } from '../abi/index.js';
-import { computeArtifactFunctionTree, computeArtifactHash, computeArtifactHashPreimage, computeFunctionArtifactHash, computeFunctionMetadataHash, getArtifactMerkleTreeHasher } from './artifact_hash.js';
-import { getContractClassPrivateFunctionFromArtifact } from './contract_class.js';
-import { computePrivateFunctionLeaf, computePrivateFunctionsTree } from './private_function.js';
-/**
- * Creates a membership proof for a private function in a contract class, to be verified via `isValidPrivateFunctionMembershipProof`.
- * @param selector - Selector of the function to create the proof for.
- * @param artifact - Artifact of the contract class where the function is defined.
- */ export async function createPrivateFunctionMembershipProof(selector, artifact) {
-    const log = createLogger('circuits:function_membership_proof');
-    // Locate private function definition and artifact
-    const privateFunctions = artifact.functions.filter((fn)=>fn.functionType === FunctionType.PRIVATE);
-    const privateFunctionsFromArtifact = await Promise.all(privateFunctions.map(getContractClassPrivateFunctionFromArtifact));
-    const privateFunction = privateFunctionsFromArtifact.find((fn)=>fn.selector.equals(selector));
-    const privateFunctionsAndSelectors = await Promise.all(privateFunctions.map(async (fn)=>({
-            fn,
-            selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters)
-        })));
-    const privateFunctionArtifact = privateFunctionsAndSelectors.find((fnAndSelector)=>selector.equals(fnAndSelector.selector))?.fn;
-    if (!privateFunction || !privateFunctionArtifact) {
-        throw new Error(`Private function with selector ${selector.toString()} not found`);
-    }
-    // Compute preimage for the artifact hash
-    const { unconstrainedFunctionRoot: unconstrainedFunctionsArtifactTreeRoot, metadataHash: artifactMetadataHash } = await computeArtifactHashPreimage(artifact);
-    // We need two sibling paths because private function information is split across two trees:
-    // The "private function tree" captures the selectors and verification keys, and is used in the kernel circuit for verifying the proof generated by the app circuit.
-    const functionLeaf = await computePrivateFunctionLeaf(privateFunction);
-    const functionsTree = await computePrivateFunctionsTree(privateFunctionsFromArtifact);
-    const functionsTreeLeafIndex = functionsTree.getIndex(functionLeaf);
-    const functionsTreeSiblingPath = functionsTree.getSiblingPath(functionsTreeLeafIndex).map(Fr.fromBuffer);
-    // And the "artifact tree" captures function bytecode and metadata, and is used by the pxe to check that its executing the code it's supposed to be executing, but it never goes into circuits.
-    const functionMetadataHash = computeFunctionMetadataHash(privateFunctionArtifact);
-    const functionArtifactHash = await computeFunctionArtifactHash({
-        ...privateFunctionArtifact,
-        functionMetadataHash
-    });
-    const artifactTree = await computeArtifactFunctionTree(artifact, FunctionType.PRIVATE);
-    const artifactTreeLeafIndex = artifactTree.getIndex(functionArtifactHash.toBuffer());
-    const artifactTreeSiblingPath = artifactTree.getSiblingPath(artifactTreeLeafIndex).map(Fr.fromBuffer);
-    log.debug(`Computed proof for private function with selector ${selector.toString()}`, {
-        functionArtifactHash,
-        functionMetadataHash,
-        functionLeaf: '0x' + functionLeaf.toString('hex'),
-        artifactMetadataHash,
-        privateFunctionsTreeRoot: '0x' + functionsTree.root.toString('hex'),
-        unconstrainedFunctionsArtifactTreeRoot,
-        artifactFunctionTreeSiblingPath: artifactTreeSiblingPath.map((fr)=>fr.toString()).join(','),
-        privateFunctionTreeSiblingPath: functionsTreeSiblingPath.map((fr)=>fr.toString()).join(',')
-    });
-    return {
-        artifactTreeSiblingPath,
-        artifactTreeLeafIndex,
-        artifactMetadataHash,
-        functionMetadataHash,
-        unconstrainedFunctionsArtifactTreeRoot,
-        privateFunctionTreeSiblingPath: functionsTreeSiblingPath,
-        privateFunctionTreeLeafIndex: functionsTreeLeafIndex
-    };
-}
-/**
- * Verifies that a private function with a membership proof as emitted by the ClassRegisterer contract is valid,
- * as defined in the protocol specs at contract-deployment/classes:
- *
- * ```
- * // Load contract class from local db
- * contract_class = db.get_contract_class(contract_class_id)
- *
- * // Compute function leaf and assert it belongs to the private functions tree
- * function_leaf = pedersen([selector as Field, vk_hash], GENERATOR__FUNCTION_LEAF)
- * computed_private_function_tree_root = compute_root(function_leaf, private_function_tree_sibling_path)
- * assert computed_private_function_tree_root == contract_class.private_function_root
- *
- * // Compute artifact leaf and assert it belongs to the artifact
- * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
- * computed_artifact_private_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path)
- * computed_artifact_hash = sha256(computed_artifact_private_function_tree_root, unconstrained_functions_artifact_tree_root, artifact_metadata_hash)
- * assert computed_artifact_hash == contract_class.artifact_hash
- * ```
- * @param fn - Function to check membership proof for.
- * @param contractClass - In which contract class the function is expected to be.
- */ export async function isValidPrivateFunctionMembershipProof(fn, contractClass) {
-    const log = createLogger('circuits:function_membership_proof');
-    // Check private function tree membership
-    const functionLeaf = await computePrivateFunctionLeaf(fn);
-    const rootBuffer = await computeRootFromSiblingPath(functionLeaf, fn.privateFunctionTreeSiblingPath.map((fr)=>fr.toBuffer()), fn.privateFunctionTreeLeafIndex, async (left, right)=>(await poseidon2Hash([
-            left,
-            right
-        ])).toBuffer());
-    const computedPrivateFunctionTreeRoot = Fr.fromBuffer(rootBuffer);
-    if (!contractClass.privateFunctionsRoot.equals(computedPrivateFunctionTreeRoot)) {
-        log.debug(`Private function tree root mismatch`, {
-            expectedPrivateFunctionTreeRoot: contractClass.privateFunctionsRoot,
-            computedPrivateFunctionTreeRoot: computedPrivateFunctionTreeRoot,
-            computedFunctionLeaf: '0x' + functionLeaf.toString('hex')
-        });
-        return false;
-    }
-    // Check artifact hash
-    const functionArtifactHash = await computeFunctionArtifactHash(fn);
-    const computedArtifactPrivateFunctionTreeRootBuffer = await computeRootFromSiblingPath(functionArtifactHash.toBuffer(), fn.artifactTreeSiblingPath.map((fr)=>fr.toBuffer()), fn.artifactTreeLeafIndex, getArtifactMerkleTreeHasher());
-    const computedArtifactPrivateFunctionTreeRoot = Fr.fromBuffer(computedArtifactPrivateFunctionTreeRootBuffer);
-    const computedArtifactHash = await computeArtifactHash({
-        privateFunctionRoot: computedArtifactPrivateFunctionTreeRoot,
-        unconstrainedFunctionRoot: fn.unconstrainedFunctionsArtifactTreeRoot,
-        metadataHash: fn.artifactMetadataHash
-    });
-    if (!contractClass.artifactHash.equals(computedArtifactHash)) {
-        log.debug(`Artifact hash mismatch`, {
-            expected: contractClass.artifactHash,
-            computedArtifactHash,
-            computedFunctionArtifactHash: functionArtifactHash,
-            computedArtifactPrivateFunctionTreeRoot,
-            unconstrainedFunctionRoot: fn.unconstrainedFunctionsArtifactTreeRoot,
-            metadataHash: fn.artifactMetadataHash,
-            artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map((fr)=>fr.toString()).join(',')
-        });
-        return false;
-    }
-    return true;
-}