pool+batches: update batchStore to support multiple lease durations

Author: jamaljsr

app/src/__tests__/components/pool/BatchRow.spec.tsx

@@ -15,7 +15,7 @@ describe('BatchRow', () => {
   });
 
   const render = () => {
-    batch = new Batch(store, poolBatchSnapshot);
+    batch = new Batch(store, 2016, poolBatchSnapshot);
     return renderWithProviders(<BatchRow batch={batch} />, store);
   };
 

app/src/__tests__/components/pool/OrderFormSection.spec.tsx

@@ -153,7 +153,7 @@ describe('OrderFormSection', () => {
 
   it('should suggest the correct premium', async () => {
     const { getByText, getByLabelText, changeInput } = render();
-    await store.batchStore.fetchLatestBatch();
+    await store.batchStore.fetchBatches();
 
     store.batchStore.sortedBatches[0].clearingPriceRate = 496;
     changeInput('Desired Inbound Liquidity', '1000000');

app/src/__tests__/store/batchStore.spec.ts

@@ -1,9 +1,9 @@
-import { runInAction, values } from 'mobx';
+import { keys, runInAction, values } from 'mobx';
 import * as AUCT from 'types/generated/auctioneer_pb';
 import { grpc } from '@improbable-eng/grpc-web';
 import { waitFor } from '@testing-library/react';
 import * as config from 'config';
-import { hex } from 'util/strings';
+import { b64, hex } from 'util/strings';
 import { injectIntoGrpcUnary } from 'util/tests';
 import {
   poolBatchSnapshot,
@@ -30,8 +30,9 @@ describe('BatchStore', () => {
     grpcMock.unary.mockImplementation((desc, opts) => {
       let res: any;
       if (desc.methodName === 'BatchSnapshots') {
+        const count = (opts.request.toObject() as any).numBatchesBack;
         res = {
-          batchesList: [...Array(20)].map((_, i) => ({
+          batchesList: [...Array(count)].map((_, i) => ({
             ...poolBatchSnapshot,
             batchId: `${index + i}-${poolBatchSnapshot.batchId}`,
             prevBatchId: `${index + i}-${poolBatchSnapshot.prevBatchId}`,
@@ -51,38 +52,39 @@ describe('BatchStore', () => {
 
   it('should fetch batches', async () => {
     expect(store.batches.size).toBe(0);
-    expect(store.orderedIds.length).toBe(0);
 
     await store.fetchBatches();
     expect(store.batches.size).toBe(BATCH_QUERY_LIMIT);
-    expect(store.orderedIds.length).toBe(BATCH_QUERY_LIMIT);
   });
 
   it('should append start from the oldest batch when fetching batches multiple times', async () => {
     expect(store.batches.size).toBe(0);
-    expect(store.orderedIds.length).toBe(0);
 
     await store.fetchBatches();
     expect(store.batches.size).toBe(BATCH_QUERY_LIMIT);
-    expect(store.orderedIds.length).toBe(BATCH_QUERY_LIMIT);
 
     // calling a second time should append new batches to the list
     await store.fetchBatches();
     expect(store.batches.size).toBe(BATCH_QUERY_LIMIT * 2);
-    expect(store.orderedIds.length).toBe(BATCH_QUERY_LIMIT * 2);
   });
 
   it('should handle a number of batches less than the query limit', async () => {
     // mock the BatchSnapshot response to return 5 batches with the last one having a
     // blank prevBatchId to signify that there are no more batches available
-    grpcMock.unary.mockImplementation((_, opts) => {
-      const res = {
-        batchesList: [...Array(5)].map((_, i) => ({
-          ...poolBatchSnapshot,
-          batchId: `${i}-${poolBatchSnapshot.batchId}`,
-          prevBatchId: index < 4 ? `${i}-${poolBatchSnapshot.prevBatchId}` : '',
-        })),
-      };
+    grpcMock.unary.mockImplementation((desc, opts) => {
+      let res: any;
+      if (desc.methodName === 'BatchSnapshots') {
+        res = {
+          batchesList: [...Array(5)].map((_, i) => ({
+            ...poolBatchSnapshot,
+            batchId: b64(`${hex(poolBatchSnapshot.batchId)}0${i}`),
+            prevBatchId: i < 4 ? b64(`${hex(poolBatchSnapshot.prevBatchId)}0${i}`) : '',
+          })),
+        };
+        index += BATCH_QUERY_LIMIT;
+      } else if (desc.methodName === 'LeaseDurations') {
+        res = poolLeaseDurations;
+      }
       opts.onEnd({
         status: grpc.Code.OK,
         message: { toObject: () => res },
@@ -94,11 +96,21 @@ describe('BatchStore', () => {
 
     await store.fetchBatches();
     expect(store.batches.size).toBe(5);
+
+    await store.fetchBatches();
+    expect(store.batches.size).toBe(5);
   });
 
   it('should handle errors when fetching batches', async () => {
-    grpcMock.unary.mockImplementationOnce(() => {
-      throw new Error('test-err');
+    grpcMock.unary.mockImplementation((desc, opts) => {
+      if (desc.methodName === 'BatchSnapshots') {
+        throw new Error('test-err');
+      }
+      opts.onEnd({
+        status: grpc.Code.OK,
+        message: { toObject: () => poolLeaseDurations },
+      } as any);
+      return undefined as any;
     });
     expect(rootStore.appView.alerts.size).toBe(0);
     await store.fetchBatches();
@@ -107,8 +119,15 @@ describe('BatchStore', () => {
   });
 
   it('should not show error when last snapshot is not found', async () => {
-    grpcMock.unary.mockImplementationOnce(() => {
-      throw new Error('batch snapshot not found');
+    grpcMock.unary.mockImplementation((desc, opts) => {
+      if (desc.methodName === 'BatchSnapshots') {
+        throw new Error('batch snapshot not found');
+      }
+      opts.onEnd({
+        status: grpc.Code.OK,
+        message: { toObject: () => poolLeaseDurations },
+      } as any);
+      return undefined as any;
     });
     expect(rootStore.appView.alerts.size).toBe(0);
     await store.fetchBatches();
@@ -117,20 +136,19 @@ describe('BatchStore', () => {
 
   it('should fetch the latest batch', async () => {
     await store.fetchBatches();
-    expect(store.orderedIds.length).toBe(BATCH_QUERY_LIMIT);
+    expect(store.batches.size).toBe(BATCH_QUERY_LIMIT);
 
     // return the same last batch to ensure no new data is added
     const lastBatchId = store.sortedBatches[0].batchId;
     index--;
     await store.fetchLatestBatch();
-    expect(store.orderedIds.length).toBe(BATCH_QUERY_LIMIT);
+    expect(store.batches.size).toBe(BATCH_QUERY_LIMIT);
     expect(store.sortedBatches[0].batchId).toBe(lastBatchId);
 
     // return a new batch as the latest
     index = 100;
     await store.fetchLatestBatch();
-    expect(store.orderedIds.length).toBe(BATCH_QUERY_LIMIT + 1);
-    expect(store.orderedIds[0]).toBe(hex(`100-${poolBatchSnapshot.batchId}`));
+    expect(store.batches.size).toBe(BATCH_QUERY_LIMIT + 1);
   });
 
   it('should handle errors when fetching the latest batch', async () => {
@@ -205,6 +223,28 @@ describe('BatchStore', () => {
     expect(store.nodeTier).toBe(AUCT.NodeTier.TIER_0);
   });
 
+  it('should handle errors when fetching node tier', async () => {
+    grpcMock.unary.mockImplementationOnce(() => {
+      throw new Error('test-err');
+    });
+    expect(rootStore.appView.alerts.size).toBe(0);
+    await store.fetchNodeTier();
+    expect(rootStore.appView.alerts.size).toBe(1);
+    expect(values(rootStore.appView.alerts)[0].message).toBe('test-err');
+  });
+
+  it('should set the active market', async () => {
+    expect(store.selectedLeaseDuration).toBe(0);
+    await store.fetchBatches();
+    expect(store.selectedLeaseDuration).toBe(2016);
+    expect(keys(store.leaseDurations)).toEqual([2016, 4032, 6048, 8064]);
+    store.setActiveMarket(4032);
+    expect(store.selectedLeaseDuration).toBe(4032);
+    store.setActiveMarket(5000);
+    expect(store.selectedLeaseDuration).toBe(4032);
+    expect(rootStore.appView.alerts.size).toBe(1);
+  });
+
   it('should start and stop polling', async () => {
     let callCount = 0;
     injectIntoGrpcUnary(desc => {

app/src/store/models/batch.ts

@@ -1,5 +1,6 @@
 import { makeAutoObservable, observable } from 'mobx';
 import * as AUCT from 'types/generated/auctioneer_pb';
+import { LeaseDuration } from 'types/state';
 import Big from 'big.js';
 import { toPercent } from 'util/bigmath';
 import { ellipseInside, hex } from 'util/strings';
@@ -37,6 +38,9 @@ class MatchedOrder {
   }
 }
 
+/**
+ * Represents a batch with only orders for a specific lease duration
+ */
 export default class Batch {
   private _store: Store;
   // native values from the POOL api
@@ -47,14 +51,22 @@ export default class Batch {
   batchTxFeeRateSatPerKw = 0;
   matchedOrders: MatchedOrder[] = [];
 
-  constructor(store: Store, llmBatch: AUCT.BatchSnapshotResponse.AsObject) {
+  // the provided lease duration to filter orders by
+  leaseDuration: LeaseDuration;
+
+  constructor(
+    store: Store,
+    duration: LeaseDuration,
+    llmBatch: AUCT.BatchSnapshotResponse.AsObject,
+  ) {
     makeAutoObservable(
       this,
       { matchedOrders: observable },
       { deep: false, autoBind: true },
     );
 
     this._store = store;
+    this.leaseDuration = duration;
     this.update(llmBatch);
   }
 
@@ -153,18 +165,18 @@ export default class Batch {
     this.prevBatchId = hex(llmBatch.prevBatchId);
     this.batchTxId = llmBatch.batchTxId;
     this.batchTxFeeRateSatPerKw = llmBatch.batchTxFeeRateSatPerKw;
-    // temporary fix to keep a batch level rate. Now that pool supports multiple
-    // durations, the rate per matched order will vary. The rate for orders with
-    // the same duration should be the same. In the future, we should group orders
-    // by their duration so they can be displayed in separate charts
-    if (llmBatch.matchedOrdersList.length > 0) {
-      this.clearingPriceRate = llmBatch.matchedOrdersList[0].matchingRate;
-    }
-    this.matchedOrders = llmBatch.matchedOrdersList
-      // there should never be a match that does not have both a bid and an ask, but
-      // the proto -> TS compiler makes these objects optional. This filter is just
-      // a sanity check to avoid unexpected errors
-      .filter(m => m.ask && m.bid)
-      .map(m => new MatchedOrder(m as Required<AUCT.MatchedOrderSnapshot.AsObject>));
+    // loop over all markets to limit the orders of this batch to a specific lease duration
+    llmBatch.matchedMarketsMap.forEach(([duration, market]) => {
+      // ignore markets for other lease durations
+      if (duration === this.leaseDuration) {
+        this.clearingPriceRate = market.clearingPriceRate;
+        this.matchedOrders = market.matchedOrdersList
+          // there should never be a match that does not have both a bid and an ask, but
+          // the proto -> TS compiler makes these objects optional. This filter is just
+          // a sanity check to avoid unexpected errors
+          .filter(m => m.ask && m.bid)
+          .map(m => new MatchedOrder(m as Required<AUCT.MatchedOrderSnapshot.AsObject>));
+      }
+    });
   }
 }

app/src/store/models/index.ts

@@ -5,3 +5,4 @@ export { default as Account } from './account';
 export { default as Order } from './order';
 export { default as Lease } from './lease';
 export { default as Batch } from './batch';
+export { default as Market } from './market';

app/src/store/models/market.ts

@@ -0,0 +1,73 @@
+import { makeAutoObservable, observable, ObservableMap } from 'mobx';
+import * as AUCT from 'types/generated/auctioneer_pb';
+import { hex } from 'util/strings';
+import { Store } from 'store';
+import { Batch } from './';
+
+/**
+ * Represents a list of batches for a specific lease duration.
+ */
+export default class Market {
+  private _store: Store;
+
+  /** the lease duration of this market */
+  leaseDuration: number;
+
+  /** the collection of batches in this market */
+  batches: ObservableMap<string, Batch> = observable.map();
+
+  /**
+   * store the order of batches so that new batches can be inserted at the front
+   * and old batches appended at the end
+   */
+  orderedIds: string[] = [];
+
+  constructor(store: Store, duration: number) {
+    makeAutoObservable(this, {}, { deep: false, autoBind: true });
+
+    this._store = store;
+    this.leaseDuration = duration;
+  }
+
+  /**
+   * all batches sorted by newest first
+   */
+  get sortedBatches() {
+    return (
+      this.orderedIds
+        .map(id => this.batches.get(id))
+        // filter out empty batches
+        .filter(b => !!b && b.clearingPriceRate > 0) as Batch[]
+    );
+  }
+
+  /**
+   * the oldest batch that we have queried from the API
+   */
+  get oldestBatch() {
+    return this.sortedBatches[this.sortedBatches.length - 1];
+  }
+
+  /**
+   * Updates the collection of batches given an array of batches from the pool API.
+   * In each batch, only the matched orders for this market will be included. Orders
+   * for other markets will be filtered out.
+   */
+  update(poolBatches: AUCT.BatchSnapshotResponse.AsObject[], appendToFront: boolean) {
+    poolBatches.forEach(poolBatch => {
+      const batchId = hex(poolBatch.batchId);
+      const existing = this.batches.get(batchId);
+      // add the batch if it's not already stored in state
+      if (!existing) {
+        const batch = new Batch(this._store, this.leaseDuration, poolBatch);
+        this.batches.set(batch.batchId, batch);
+        // add this batch's id to the orderedIds array
+        this.orderedIds = appendToFront
+          ? [batch.batchId, ...this.orderedIds]
+          : [...this.orderedIds, batch.batchId];
+      } else {
+        existing.update(poolBatch);
+      }
+    });
+  }
+}