Merge pull request #29 from AztecProtocol/stage

Release merge

yarn-project/barretenberg.js/src/client_proofs/proof_data/proof_data.ts

@@ -81,7 +81,7 @@ export class ProofData {
  public readonly backwardLink: Buffer;
  public readonly allowChain: Buffer;
 
- constructor(public rawProofData: Buffer) {
+ constructor(public rawProofData: Buffer, txId?: Buffer) {
  this.proofId = rawProofData.readUInt32BE(ProofDataOffsets.PROOF_ID);
  this.noteCommitment1 = rawProofData.slice(
  ProofDataOffsets.NOTE_COMMITMENT_1,
@@ -109,6 +109,8 @@ export class ProofData {
  this.defiRoot = rawProofData.slice(ProofDataOffsets.DEFI_ROOT, ProofDataOffsets.DEFI_ROOT + 32);
  this.backwardLink = rawProofData.slice(ProofDataOffsets.BACKWARD_LINK, ProofDataOffsets.BACKWARD_LINK + 32);
  this.allowChain = rawProofData.slice(ProofDataOffsets.ALLOW_CHAIN, ProofDataOffsets.ALLOW_CHAIN + 32);
+
+ this.txId_ = txId;
  }
 
  get allowChainFromNote1() {

yarn-project/falafel/src/app.ts

@@ -348,7 +348,7 @@ export function appFactory(server: Server, prefix: string, metrics: Metrics, ser
 
  router.get('/get-pending-txs', recordMetric, async (ctx: Koa.Context) => {
  const txs = await server.getUnsettledTxs();
- ctx.body = txs.map(tx => new ProofData(tx.proofData)).map(toPendingTxJson);
+ ctx.body = txs.map(tx => new ProofData(tx.proofData, tx.id)).map(toPendingTxJson);
  ctx.status = 200;
  });
 

yarn-project/falafel/src/world_state.ts

@@ -71,8 +71,7 @@ type TxPoolProfile = {
 export class WorldState {
  private serialQueue = new SerialQueue();
  private pipeline?: RollupPipeline;
- private txPoolProfile!: TxPoolProfile;
- private txPoolProfileValidUntil!: Date;
+ private txPoolProfile?: Promise<TxPoolProfile>;
  private initialSubtreeRootsCache: Buffer[] = [];
  private bridgeStatsQueryHandler: BridgeStatsQueryHandler;
 
@@ -88,13 +87,6 @@ export class WorldState {
  private expireTxPoolAfter = 60 * 1000,
  private log = createLogger('WorldState'),
  ) {
- this.txPoolProfile = {
- numTxs: 0,
- numTxsInNextRollup: 0,
- pendingTxCount: 0,
- pendingSecondClassTxCount: 0,
- pendingBridgeStats: [],
- };
  this.bridgeStatsQueryHandler = new BridgeStatsQueryHandler(rollupDb, txFeeResolver);
  }
 
@@ -136,45 +128,10 @@ export class WorldState {
  }
 
  public async getTxPoolProfile() {
- // getPendingTxs from rollup db
- // remove the tranasctions that we know are in the next rollup currently being built
- if (!this.txPoolProfileValidUntil || new Date().getTime() > this.txPoolProfileValidUntil.getTime()) {
- const pendingTxs = await this.rollupDb.getPendingTxs();
- const processedTransactions = this.pipeline?.getProcessedTxs() || [];
- const pendingTransactionsNotInRollup = pendingTxs.filter(elem =>
- processedTransactions.every(tx => !tx.id.equals(elem.id)),
- );
-
- const pendingBridgeStats: Map<bigint, BridgeStat> = new Map();
- for (const tx of pendingTransactionsNotInRollup) {
- const proof = new ProofData(tx.proofData);
- if (proof.proofId !== ProofId.DEFI_DEPOSIT) {
- continue;
- }
-
- const defiProof = new DefiDepositProofData(proof);
- const rollupTx = createDefiRollupTx(tx, defiProof);
- const bridgeCallData = rollupTx.bridgeCallData!;
- const bridgeProfile = pendingBridgeStats.get(bridgeCallData) || {
- bridgeCallData,
- gasAccrued: 0,
- };
- bridgeProfile.gasAccrued += this.txFeeResolver.getSingleBridgeTxGas(bridgeCallData) + rollupTx.excessGas;
-
- pendingBridgeStats.set(bridgeCallData, bridgeProfile);
- }
-
- this.txPoolProfile = {
- numTxs: await this.rollupDb.getUnsettledTxCount(),
- numTxsInNextRollup: processedTransactions.length,
- pendingBridgeStats: [...pendingBridgeStats.values()],
- pendingTxCount: pendingTransactionsNotInRollup.length,
- pendingSecondClassTxCount: await this.rollupDb.getPendingSecondClassTxCount(),
- };
- this.txPoolProfileValidUntil = new Date(Date.now() + this.expireTxPoolAfter);
+ if (!this.txPoolProfile) {
+ this.txPoolProfile = this.computeTxPoolProfile();
  }
-
- return this.txPoolProfile;
+ return await this.txPoolProfile;
  }
 
  public async queryBridgeStats(query: BridgePublishQuery) {
@@ -821,4 +778,52 @@ export class WorldState {
 
  await this.worldStateDb.commit();
  }
+
+ /**
+ * getPendingTxs from rollup db
+ * remove the tranasctions that we know are in the next rollup currently being built
+ */
+ private async computeTxPoolProfile() {
+ const pendingTxs = await this.rollupDb.getPendingTxs();
+ const processedTransactions = this.pipeline?.getProcessedTxs() || [];
+
+ const txsBeingProcessed = new Set(processedTransactions.map(tx => tx.id.toString('hex')));
+
+ const pendingTransactionsNotBeingProcessed = pendingTxs.filter(
+ elem => !txsBeingProcessed.has(elem.id.toString('hex')),
+ );
+
+ const pendingBridgeStats: Map<bigint, BridgeStat> = new Map();
+ for (const tx of pendingTransactionsNotBeingProcessed) {
+ const proof = new ProofData(tx.proofData);
+ if (proof.proofId !== ProofId.DEFI_DEPOSIT) {
+ continue;
+ }
+
+ const defiProof = new DefiDepositProofData(proof);
+ const rollupTx = createDefiRollupTx(tx, defiProof);
+ const bridgeCallData = rollupTx.bridgeCallData!;
+ const bridgeProfile = pendingBridgeStats.get(bridgeCallData) || {
+ bridgeCallData,
+ gasAccrued: 0,
+ };
+ bridgeProfile.gasAccrued += this.txFeeResolver.getSingleBridgeTxGas(bridgeCallData) + rollupTx.excessGas;
+
+ pendingBridgeStats.set(bridgeCallData, bridgeProfile);
+ }
+
+ setTimeout(() => {
+ this.txPoolProfile = undefined;
+ }, this.expireTxPoolAfter);
+
+ const result: TxPoolProfile = {
+ numTxs: await this.rollupDb.getUnsettledTxCount(),
+ numTxsInNextRollup: processedTransactions.length,
+ pendingBridgeStats: [...pendingBridgeStats.values()],
+ pendingTxCount: pendingTransactionsNotBeingProcessed.length,
+ pendingSecondClassTxCount: await this.rollupDb.getPendingSecondClassTxCount(),
+ };
+
+ return result;
+ }
 }

yarn-project/sdk/src/core_sdk/block_downloader.ts

@@ -11,10 +11,17 @@ export class BlockDownloader {
  private interruptableSleep = new InterruptableSleep();
  private semaphore: Semaphore;
  private queue = new MemoryFifo<Block[]>();
+ private genesisTake;
  private debug = createDebugLogger('bb:block_downloader');
 
- constructor(private rollupProvider: RollupProvider, maxQueueSize: number, private initialTreeSize: number) {
+ constructor(private rollupProvider: RollupProvider, maxQueueSize: number, initialTreeSize: number) {
  this.semaphore = new Semaphore(maxQueueSize);
+ // Choosing 55 as an initial chunk to insert if starting from 0, is an aztec-connect optimisation.
+ // The aztec-connect genesis data consists of 73 rollups.
+ // Initially inserting 55 brings us to 128, after which we work with chunks of 128 rollups.
+ // If not synching from zero, the chunk size is whatever takes us up to the next 128 alignment.
+ // This allows for optimal subtree insertions in the client side merkle tree for better sync performance.
+ this.genesisTake = 128 - (initialTreeSize % 128);
  }
 
  public start(from = 0) {
@@ -31,13 +38,12 @@ export class BlockDownloader {
  const fn = async () => {
  while (this.running) {
  try {
- // Choosing 55 as an initial chunk to insert if starting from 0, is an aztec-connect optimisation.
- // The aztec-connect genesis data consists of 73 rollups.
- // Initially inserting 55 brings us to 128, after which we work with chunks of 128 rollups.
- // If not synching from zero, the chunk size is whatever takes us up to the next 128 alignment.
- // This allows for optimal subtree insertions in the client side merkle tree for better sync performance.
- const initialTake = 128 - ((this.from === 0 ? this.initialTreeSize : this.from) % 128);
- const blocks = await this.rollupProvider.getBlocks(this.from, this.from === from ? initialTake : 128);
+ // If requesting from block 0, then take the fixed number of blocks to take us to 128 (genesisTake)
+ // Otherwise, take blocks as required to get us to a 128 aligned boundary starting from block (128 - initialTreeSize).
+ // e.g. we are trying to get to blocks 183, 311, 439 etc....
+ const takeValue =
+ this.from < this.genesisTake ? this.genesisTake - this.from : 128 - ((this.from - this.genesisTake) % 128);
+ const blocks = await this.rollupProvider.getBlocks(this.from, takeValue);
 
  if (!blocks.length) {
  await this.interruptableSleep.sleep(10000);