@aztec/sequencer-client 0.32.1 → 0.34.0

package/src/sequencer/sequencer.ts

@@ -1,7 +1,7 @@
 import { type L1ToL2MessageSource, type L2Block, type L2BlockSource, type ProcessedTx, Tx } from '@aztec/circuit-types';
 import { type BlockProver, PROVING_STATUS } from '@aztec/circuit-types/interfaces';
 import { type L2BlockBuiltStats } from '@aztec/circuit-types/stats';
-import { AztecAddress, EthAddress, type GlobalVariables } from '@aztec/circuits.js';
+import { AztecAddress, EthAddress } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -52,7 +52,7 @@ export class Sequencer {
     private log = createDebugLogger('aztec:sequencer'),
   ) {
     this.updateConfig(config);
-    this.log(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
+    this.log.verbose(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
   }
 
   /**
@@ -92,25 +92,25 @@ export class Sequencer {
     this.runningPromise = new RunningPromise(this.work.bind(this), this.pollingIntervalMs);
     this.runningPromise.start();
     this.state = SequencerState.IDLE;
-    this.log('Sequencer started');
+    this.log.info('Sequencer started');
   }
 
   /**
    * Stops the sequencer from processing txs and moves to STOPPED state.
    */
   public async stop(): Promise<void> {
-    this.log(`Stopping sequencer`);
+    this.log.debug(`Stopping sequencer`);
     await this.runningPromise?.stop();
     this.publisher.interrupt();
     this.state = SequencerState.STOPPED;
-    this.log('Stopped sequencer');
+    this.log.info('Stopped sequencer');
   }
 
   /**
    * Starts a previously stopped sequencer.
    */
   public restart() {
-    this.log('Restarting sequencer');
+    this.log.info('Restarting sequencer');
     this.publisher.restart();
     this.runningPromise!.start();
     this.state = SequencerState.IDLE;
@@ -137,7 +137,7 @@ export class Sequencer {
       // Update state when the previous block has been synced
       const prevBlockSynced = await this.isBlockSynced();
       if (prevBlockSynced && this.state === SequencerState.PUBLISHING_BLOCK) {
-        this.log(`Block has been synced`);
+        this.log.debug(`Block has been synced`);
         this.state = SequencerState.IDLE;
       }
 
@@ -193,57 +193,75 @@ export class Sequencer {
       this.log.info(`Building block ${newBlockNumber} with ${validTxs.length} transactions`);
       this.state = SequencerState.CREATING_BLOCK;
 
+      // Get l1 to l2 messages from the contract
+      this.log.debug('Requesting L1 to L2 messages from contract');
+      const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(newBlockNumber));
+      this.log.verbose(`Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newBlockNumber}`);
+
       // We create a fresh processor each time to reset any cached state (eg storage writes)
       const processor = await this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
-      const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() => processor.process(validTxs));
+
+      const emptyTx = processor.makeEmptyProcessedTx();
+
+      const blockBuildingTimer = new Timer();
+
+      // We must initialise the block to be a power of 2 in size
+      const numRealTxs = validTxs.length;
+      const pow2 = Math.log2(numRealTxs);
+      const totalTxs = 2 ** Math.ceil(pow2);
+      const blockSize = Math.max(2, totalTxs);
+      const blockTicket = await this.prover.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages, emptyTx);
+
+      const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
+        processor.process(validTxs, blockSize, this.prover, txValidator),
+      );
       if (failedTxs.length > 0) {
         const failedTxData = failedTxs.map(fail => fail.tx);
-        this.log(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
+        this.log.debug(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
         await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
       }
 
-      // Only accept processed transactions that are not double-spends,
-      // public functions emitting nullifiers would pass earlier check but fail here.
-      // Note that we're checking all nullifiers generated in the private execution twice,
-      // we could store the ones already checked and skip them here as an optimization.
-      const processedValidTxs = await this.takeValidTxs(processedTxs, txValidator);
-
-      if (processedValidTxs.length === 0) {
-        this.log('No txs processed correctly to build block. Exiting');
+      if (processedTxs.length === 0) {
+        this.log.verbose('No txs processed correctly to build block. Exiting');
+        this.prover.cancelBlock();
         return;
       }
 
       await assertBlockHeight();
 
-      // Get l1 to l2 messages from the contract
-      this.log('Requesting L1 to L2 messages from contract');
-      const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(newBlockNumber));
-      this.log(`Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newBlockNumber}`);
+      // All real transactions have been added, set the block as full and complete the proving.
+      await this.prover.setBlockCompleted();
 
-      // Build the new block by running the rollup circuits
-      this.log(`Assembling block with txs ${processedValidTxs.map(tx => tx.hash).join(', ')}`);
+      // Here we are now waiting for the block to be proven.
+      // TODO(@PhilWindle) We should probably periodically check for things like another
+      // block being published before ours instead of just waiting on our block
+      const result = await blockTicket.provingPromise;
+      if (result.status === PROVING_STATUS.FAILURE) {
+        throw new Error(`Block proving failed, reason: ${result.reason}`);
+      }
 
       await assertBlockHeight();
 
-      const emptyTx = processor.makeEmptyProcessedTx();
-      const [rollupCircuitsDuration, block] = await elapsed(() =>
-        this.buildBlock(processedValidTxs, l1ToL2Messages, emptyTx, newGlobalVariables),
-      );
+      // Block is proven, now finalise and publish!
+      const blockResult = await this.prover.finaliseBlock();
+      const block = blockResult.block;
+
+      await assertBlockHeight();
 
-      this.log(`Assembled block ${block.number}`, {
+      this.log.verbose(`Assembled block ${block.number}`, {
         eventName: 'l2-block-built',
         duration: workTimer.ms(),
         publicProcessDuration: publicProcessorDuration,
-        rollupCircuitsDuration: rollupCircuitsDuration,
+        rollupCircuitsDuration: blockBuildingTimer.ms(),
         ...block.getStats(),
       } satisfies L2BlockBuiltStats);
 
-      await assertBlockHeight();
-
       await this.publishL2Block(block);
-      this.log.info(`Submitted rollup block ${block.number} with ${processedValidTxs.length} transactions`);
+      this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
     } catch (err) {
       this.log.error(`Rolling back world state DB due to error assembling block`, (err as any).stack);
+      // Cancel any further proving on the block
+      this.prover?.cancelBlock();
       await this.worldState.getLatest().rollback();
     }
   }
@@ -257,7 +275,6 @@ export class Sequencer {
     this.state = SequencerState.PUBLISHING_BLOCK;
     const publishedL2Block = await this.publisher.processL2Block(block);
     if (publishedL2Block) {
-      this.log(`Successfully published block ${block.number}`);
       this.lastPublishedBlock = block.number;
     } else {
       throw new Error(`Failed to publish block`);
@@ -267,7 +284,7 @@ export class Sequencer {
   protected async takeValidTxs<T extends Tx | ProcessedTx>(txs: T[], validator: TxValidator): Promise<T[]> {
     const [valid, invalid] = await validator.validateTxs(txs);
     if (invalid.length > 0) {
-      this.log(`Dropping invalid txs from the p2p pool ${Tx.getHashes(invalid).join(', ')}`);
+      this.log.debug(`Dropping invalid txs from the p2p pool ${Tx.getHashes(invalid).join(', ')}`);
       await this.p2pClient.deleteTxs(Tx.getHashes(invalid));
     }
 
@@ -289,33 +306,6 @@ export class Sequencer {
     return min >= this.lastPublishedBlock;
   }
 
-  /**
-   * Pads the set of txs to a power of two and assembles a block by calling the block builder.
-   * @param txs - Processed txs to include in the next block.
-   * @param l1ToL2Messages - L1 to L2 messages to be part of the block.
-   * @param emptyTx - Empty tx to repeat at the end of the block to pad to a power of two.
-   * @param globalVariables - Global variables to use in the block.
-   * @returns The new block.
-   */
-  protected async buildBlock(
-    txs: ProcessedTx[],
-    l1ToL2Messages: Fr[],
-    emptyTx: ProcessedTx,
-    globalVariables: GlobalVariables,
-  ) {
-    const blockTicket = await this.prover.startNewBlock(txs.length, globalVariables, l1ToL2Messages, emptyTx);
-
-    for (const tx of txs) {
-      await this.prover.addNewTx(tx);
-    }
-
-    const result = await blockTicket.provingPromise;
-    if (result.status === PROVING_STATUS.FAILURE) {
-      throw new Error(`Block proving failed, reason: ${result.reason}`);
-    }
-    return result.block;
-  }
-
   get coinbase(): EthAddress {
     return this._coinbase;
   }

package/src/sequencer/setup_phase_manager.ts

@@ -34,7 +34,7 @@ export class SetupPhaseManager extends AbstractPhaseManager {
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
     previousPublicKernelProof: Proof,
   ) {
-    this.log(`Processing tx ${tx.getTxHash()}`);
+    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
     const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
       await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
         // the abstract phase manager throws if simulation gives error in a non-revertible phase
@@ -45,6 +45,6 @@ export class SetupPhaseManager extends AbstractPhaseManager {
       );
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
     await this.publicStateDB.checkpoint();
-    return { publicKernelOutput, publicKernelProof, revertReason };
+    return { publicKernelOutput, publicKernelProof, revertReason, returnValues: undefined };
   }
 }

package/src/sequencer/tail_phase_manager.ts

@@ -1,10 +1,19 @@
 import { type Tx } from '@aztec/circuit-types';
 import {
+  type Fr,
   type GlobalVariables,
   type Header,
+  type KernelCircuitPublicInputs,
+  MAX_NEW_NOTE_HASHES_PER_TX,
   type Proof,
   type PublicKernelCircuitPublicInputs,
+  PublicKernelTailCircuitPrivateInputs,
+  type SideEffect,
+  makeEmptyProof,
+  mergeAccumulatedData,
+  sortByCounter,
 } from '@aztec/circuits.js';
+import { type Tuple } from '@aztec/foundation/serialize';
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
@@ -27,8 +36,8 @@ export class TailPhaseManager extends AbstractPhaseManager {
   }
 
   async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs, previousPublicKernelProof: Proof) {
-    this.log(`Processing tx ${tx.getTxHash()}`);
-    const [publicKernelOutput, publicKernelProof] = await this.runKernelCircuit(
+    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
+    const [finalKernelOutput, publicKernelProof] = await this.runTailKernelCircuit(
       previousPublicKernelOutput,
       previousPublicKernelProof,
     ).catch(
@@ -42,6 +51,61 @@ export class TailPhaseManager extends AbstractPhaseManager {
     // commit the state updates from this transaction
     await this.publicStateDB.commit();
 
-    return { publicKernelOutput, publicKernelProof, revertReason: undefined };
+    return {
+      publicKernelOutput: previousPublicKernelOutput,
+      finalKernelOutput,
+      publicKernelProof,
+      revertReason: undefined,
+      returnValues: undefined,
+    };
+  }
+
+  private async runTailKernelCircuit(
+    previousOutput: PublicKernelCircuitPublicInputs,
+    previousProof: Proof,
+  ): Promise<[KernelCircuitPublicInputs, Proof]> {
+    const output = await this.simulate(previousOutput, previousProof);
+
+    // Temporary hack. Should sort them in the tail circuit.
+    const noteHashes = mergeAccumulatedData(
+      MAX_NEW_NOTE_HASHES_PER_TX,
+      previousOutput.endNonRevertibleData.newNoteHashes,
+      previousOutput.end.newNoteHashes,
+    );
+    output.end.newNoteHashes = this.sortNoteHashes<typeof MAX_NEW_NOTE_HASHES_PER_TX>(noteHashes);
+
+    return [output, makeEmptyProof()];
+  }
+
+  private async simulate(
+    previousOutput: PublicKernelCircuitPublicInputs,
+    previousProof: Proof,
+  ): Promise<KernelCircuitPublicInputs> {
+    const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
+
+    const { validationRequests, endNonRevertibleData, end } = previousOutput;
+    const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
+      validationRequests.nullifierReadRequests,
+      endNonRevertibleData.newNullifiers,
+      end.newNullifiers,
+    );
+    const nullifierNonExistentReadRequestHints = await this.hintsBuilder.getNullifierNonExistentReadRequestHints(
+      validationRequests.nullifierNonExistentReadRequests,
+      endNonRevertibleData.newNullifiers,
+      end.newNullifiers,
+    );
+    const inputs = new PublicKernelTailCircuitPrivateInputs(
+      previousKernel,
+      nullifierReadRequestHints,
+      nullifierNonExistentReadRequestHints,
+    );
+    return this.publicKernel.publicKernelCircuitTail(inputs);
+  }
+
+  private sortNoteHashes<N extends number>(noteHashes: Tuple<SideEffect, N>): Tuple<Fr, N> {
+    return sortByCounter(noteHashes.map(n => ({ ...n, counter: n.counter.toNumber() }))).map(n => n.value) as Tuple<
+      Fr,
+      N
+    >;
   }
 }

package/src/sequencer/teardown_phase_manager.ts

@@ -34,7 +34,7 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
     previousPublicKernelProof: Proof,
   ) {
-    this.log(`Processing tx ${tx.getTxHash()}`);
+    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
     const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
       await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
         // the abstract phase manager throws if simulation gives error in a non-revertible phase
@@ -45,6 +45,6 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
       );
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
     await this.publicStateDB.checkpoint();
-    return { publicKernelOutput, publicKernelProof, revertReason };
+    return { publicKernelOutput, publicKernelProof, revertReason, returnValues: undefined };
   }
 }

package/src/sequencer/tx_validator.ts

@@ -138,9 +138,7 @@ export class TxValidator {
    * @returns Whether this is a problematic double spend that the L1 contract would reject.
    */
   async #validateNullifiers(tx: Tx | ProcessedTx, thisBlockNullifiers: Set<bigint>): Promise<TxValidationStatus> {
-    const newNullifiers = [...tx.data.endNonRevertibleData.newNullifiers, ...tx.data.end.newNullifiers]
-      .filter(x => !x.isEmpty())
-      .map(x => x.value.toBigInt());
+    const newNullifiers = tx.data.getNonEmptyNullifiers().map(x => x.toBigInt());
 
     // Ditch this tx if it has repeated nullifiers
     const uniqueNullifiers = new Set(newNullifiers);
@@ -172,7 +170,7 @@ export class TxValidator {
   }
 
   async #validateGasBalance(tx: Tx): Promise<TxValidationStatus> {
-    if (!tx.data.needsTeardown) {
+    if (!tx.data.forPublic || !tx.data.forPublic.needsTeardown) {
       return VALID_TX;
     }
 
@@ -200,7 +198,11 @@ export class TxValidator {
   }
 
   #validateMaxBlockNumber(tx: Tx | ProcessedTx): TxValidationStatus {
-    const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
+    const target =
+      tx instanceof Tx
+        ? tx.data.forRollup?.rollupValidationRequests || tx.data.forPublic!.validationRequests.forRollup
+        : tx.data.rollupValidationRequests;
+    const maxBlockNumber = target.maxBlockNumber;
 
     if (maxBlockNumber.isSome && maxBlockNumber.value < this.#globalVariables.blockNumber) {
       this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for low max block number`);
@@ -211,7 +213,7 @@ export class TxValidator {
   }
 
   async #validateFee(tx: Tx): Promise<TxValidationStatus> {
-    if (!tx.data.needsTeardown) {
+    if (!tx.data.forPublic || !tx.data.forPublic.needsTeardown) {
       // TODO check if fees are mandatory and reject this tx
       this.#log.debug(`Tx ${Tx.getHash(tx)} doesn't pay for gas`);
       return VALID_TX;

package/src/sequencer/utils.ts

@@ -7,13 +7,14 @@ import { CallRequest } from '@aztec/circuits.js';
  * @returns The highest side effect counter in the transaction so far
  */
 export function lastSideEffectCounter(tx: Tx): number {
+  const data = tx.data.forPublic!;
   const sideEffectCounters = [
-    ...tx.data.endNonRevertibleData.newNoteHashes,
-    ...tx.data.endNonRevertibleData.newNullifiers,
-    ...tx.data.endNonRevertibleData.publicCallStack,
-    ...tx.data.end.newNoteHashes,
-    ...tx.data.end.newNullifiers,
-    ...tx.data.end.publicCallStack,
+    ...data.endNonRevertibleData.newNoteHashes,
+    ...data.endNonRevertibleData.newNullifiers,
+    ...data.endNonRevertibleData.publicCallStack,
+    ...data.end.newNoteHashes,
+    ...data.end.newNullifiers,
+    ...data.end.publicCallStack,
   ];
 
   let max = 0;

package/src/simulator/index.ts

@@ -1,4 +1,5 @@
 import {
+  type KernelCircuitPublicInputs,
   type PublicKernelCircuitPrivateInputs,
   type PublicKernelCircuitPublicInputs,
   type PublicKernelTailCircuitPrivateInputs,
@@ -31,5 +32,5 @@ export interface PublicKernelCircuitSimulator {
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
-  publicKernelCircuitTail(inputs: PublicKernelTailCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
+  publicKernelCircuitTail(inputs: PublicKernelTailCircuitPrivateInputs): Promise<KernelCircuitPublicInputs>;
 }

package/src/simulator/public_executor.ts

@@ -47,11 +47,11 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     // Extract contract class and instance data from logs and add to cache for this block
     const logs = tx.unencryptedLogs.unrollLogs();
     ContractClassRegisteredEvent.fromLogs(logs, getCanonicalClassRegistererAddress()).forEach(e => {
-      this.log(`Adding class ${e.contractClassId.toString()} to public execution contract cache`);
+      this.log.debug(`Adding class ${e.contractClassId.toString()} to public execution contract cache`);
       this.classCache.set(e.contractClassId.toString(), e.toContractClassPublic());
     });
     ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => {
-      this.log(
+      this.log.debug(
         `Adding instance ${e.address.toString()} with class ${e.contractClassId.toString()} to public execution contract cache`,
       );
       this.instanceCache.set(e.address.toString(), e.toContractInstance());

package/src/simulator/public_kernel.ts

@@ -1,5 +1,6 @@
 import { type CircuitSimulationStats } from '@aztec/circuit-types/stats';
 import {
+  type KernelCircuitPublicInputs,
   type PublicKernelCircuitPrivateInputs,
   type PublicKernelCircuitPublicInputs,
   type PublicKernelTailCircuitPrivateInputs,
@@ -51,7 +52,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
       this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelSetupArtifact),
     );
     const result = convertPublicSetupRollupOutputFromWitnessMap(witness);
-    this.log(`Simulated public kernel setup circuit`, {
+    this.log.debug(`Simulated public kernel setup circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-setup',
       duration,
@@ -77,7 +78,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
       this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelAppLogicArtifact),
     );
     const result = convertPublicInnerRollupOutputFromWitnessMap(witness);
-    this.log(`Simulated public kernel app logic circuit`, {
+    this.log.debug(`Simulated public kernel app logic circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-app-logic',
       duration,
@@ -103,7 +104,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
       this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTeardownArtifact),
     );
     const result = convertPublicTeardownRollupOutputFromWitnessMap(witness);
-    this.log(`Simulated public kernel teardown circuit`, {
+    this.log.debug(`Simulated public kernel teardown circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-teardown',
       duration,
@@ -120,13 +121,13 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
    */
   public async publicKernelCircuitTail(
     input: PublicKernelTailCircuitPrivateInputs,
-  ): Promise<PublicKernelCircuitPublicInputs> {
+  ): Promise<KernelCircuitPublicInputs> {
     const inputWitness = convertPublicTailInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
       this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTailArtifact),
     );
     const result = convertPublicTailOutputFromWitnessMap(witness);
-    this.log(`Simulated public kernel tail circuit`, {
+    this.log.debug(`Simulated public kernel tail circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-tail',
       duration,

package/dest/utils.d.ts

@@ -1,12 +0,0 @@
-/**
- * Returns a promise that resolves after ms milliseconds, returning "returnValue".
- * @param ms - How many milliseconds to sleep.
- * @param returnValue - The return value of the promise.
- */
-export declare function sleep<T>(ms: number, returnValue: T): Promise<T>;
-/**
- * Returns the lowest power of two that is greater of equal to the input.
- * @param num - The input.
- */
-export declare function ceilPowerOfTwo(num: number): number;
-//# sourceMappingURL=utils.d.ts.map

package/dest/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAE/D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAElD"}

package/dest/utils.js

@@ -1,16 +0,0 @@
-/**
- * Returns a promise that resolves after ms milliseconds, returning "returnValue".
- * @param ms - How many milliseconds to sleep.
- * @param returnValue - The return value of the promise.
- */
-export function sleep(ms, returnValue) {
-    return new Promise(resolve => setTimeout(() => resolve(returnValue), ms));
-}
-/**
- * Returns the lowest power of two that is greater of equal to the input.
- * @param num - The input.
- */
-export function ceilPowerOfTwo(num) {
-    return 2 ** Math.ceil(Math.log2(num));
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxLQUFLLENBQUksRUFBVSxFQUFFLFdBQWM7SUFDakQsT0FBTyxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxPQUFPLENBQUMsV0FBVyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQztBQUM1RSxDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLGNBQWMsQ0FBQyxHQUFXO0lBQ3hDLE9BQU8sQ0FBQyxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO0FBQ3hDLENBQUMifQ==

package/src/utils.ts

@@ -1,16 +0,0 @@
-/**
- * Returns a promise that resolves after ms milliseconds, returning "returnValue".
- * @param ms - How many milliseconds to sleep.
- * @param returnValue - The return value of the promise.
- */
-export function sleep<T>(ms: number, returnValue: T): Promise<T> {
-  return new Promise(resolve => setTimeout(() => resolve(returnValue), ms));
-}
-
-/**
- * Returns the lowest power of two that is greater of equal to the input.
- * @param num - The input.
- */
-export function ceilPowerOfTwo(num: number): number {
-  return 2 ** Math.ceil(Math.log2(num));
-}