feat(api): 932 record historical synthetic prices based on emp latest price (#3108)

Signed-off-by: David Adams <david@umaproject.org>

Author: David A

packages/api/src/apps/api/README.md

@@ -120,3 +120,14 @@ Get only tvl (and other future statistics) for a single emp.
 #### listEmpStats(currency: "usd" = "usd") => StatData[]
 
 Get all tvl (and other future statistics) for all known emps.
+
+### historicalSynthPricesByAddress(empAddress:string,start:number=0,end:number=Date.now()) => PriceSample[]
+
+Get a range of historical prices synthetic prices by emp address between start and end in MS, sorted by timestamp
+ascending. This is useful for charting betwen two dates. Note non synth historical prices are specified by erc20 address.
+
+### sliceHistoricalSynthPricesByAddress(address:string,start:number=0,length:number=1) => PriceSample[]
+
+Get a range of historical synthetic prices by emp address between start and count of price samples, sorted by timestamp
+ascending. This is useful for paginating data when you have X elements per page, and you know the last element seen.
+Note non synth historical prices are specified by erc20 address.

packages/api/src/apps/api/app.ts

@@ -44,6 +44,7 @@ async function run(env: ProcessEnv) {
     },
     synthPrices: {
       latest: {},
+      history: {},
     },
     erc20s: tables.erc20s.JsMap(),
     stats: {

packages/api/src/index.ts

@@ -43,6 +43,9 @@ export type AppState = {
     latest: {
       [empAddress: string]: PriceSample;
     };
+    history: {
+      [empAddress: string]: uma.tables.historicalPrices.SortedJsMap;
+    };
   };
   erc20s: uma.tables.erc20s.JsMap;
   stats: {

packages/api/src/services/actions.ts

@@ -100,6 +100,26 @@ export function Handlers(config: Config, appState: Dependencies): Actions {
       assert(stats[currency], "No stats for currency: " + currency);
       return stats[currency].latest.values();
     },
+    async historicalSynthPricesByAddress(
+      empAddress: string,
+      start = 0,
+      end: number = Date.now()
+    ): Promise<PriceSample[]> {
+      assert(empAddress, "requires emp address");
+      assert(start >= 0, "requires a start value >= 0");
+      assert(exists(synthPrices.history[empAddress]), "No synthetic prices for emp address: " + empAddress);
+      const results = await synthPrices.history[empAddress].betweenByTimestamp(start, end);
+      // convert this to tuple to save bytes.
+      return results.map(({ price, timestamp }) => [timestamp, price]);
+    },
+    async sliceHistoricalSynthPricesByAddress(empAddress: string, start = 0, length = 1): Promise<PriceSample[]> {
+      assert(empAddress, "requires emp address");
+      assert(start >= 0, "requires a start value >= 0");
+      assert(exists(synthPrices.history[empAddress]), "No synthetic prices for emp address: " + empAddress);
+      const results = await synthPrices.history[empAddress].sliceByTimestamp(start, length);
+      // convert this to tuple to save bytes.
+      return results.map(({ price, timestamp }) => [timestamp, price]);
+    },
   };
 
   // list all available actions

packages/api/src/services/synthetic-prices.ts

@@ -1,5 +1,7 @@
+import assert from "assert";
 import SynthPrices from "../libs/synthPrices";
 import { AppState, PriceSample } from "..";
+import * as uma from "@uma/sdk";
 
 type Config = {
   cryptowatchApiKey?: string;
@@ -15,30 +17,73 @@ export default function (config: Config, appState: Dependencies) {
   const { web3, emps, synthPrices } = appState;
   const getSynthPrices = SynthPrices(config, web3);
 
-  async function updatePrice(empAddress: string) {
+  // if we have a new emp address, this will create a new price table structure to store historical price data
+  function getOrCreateHistoryTable(empAddress: string) {
+    if (synthPrices.history[empAddress] == null) {
+      synthPrices.history[empAddress] = uma.tables.historicalPrices.SortedJsMap();
+    }
+    return synthPrices.history[empAddress];
+  }
+
+  // utility to grab last price based on address
+  function getLatestPriceFromTable(empAddress: string) {
+    const result = synthPrices.latest[empAddress];
+    assert(uma.utils.exists(result), "no latest sythetic price found for: " + empAddress);
+    return result;
+  }
+
+  // pulls price from latest and stuffs it into historical table.
+  async function updatePriceHistory(empAddress: string) {
+    const table = getOrCreateHistoryTable(empAddress);
+    const [timestamp, price] = getLatestPriceFromTable(empAddress);
+    // if this timestamp exists in the table, dont bother re-adding it
+    assert(uma.utils.exists(price), "No latest price available for: " + empAddress);
+    assert(
+      !(await table.hasByTimestamp(timestamp)),
+      `Synthetic price already exists for emp address ${empAddress} at timestamp: ${timestamp}`
+    );
+    return table.create({ timestamp, price });
+  }
+
+  async function updatePriceHistories(addresses: string[]) {
+    return Promise.allSettled(addresses.map(updatePriceHistory));
+  }
+
+  async function updateLatestPrice(empAddress: string) {
     const result: PriceSample = await getSynthPrices.getCurrentPrice(empAddress);
     synthPrices.latest[empAddress] = result;
     return result;
   }
-  async function updatePrices(empAddresses: string[]) {
-    return Promise.allSettled(empAddresses.map(updatePrice));
+
+  async function updateLatestPrices(empAddresses: string[]) {
+    return Promise.allSettled(empAddresses.map(updateLatestPrice));
   }
 
   async function update() {
     // synth prices are looked up by emp address, not synthetic token address
     const empAddresses = Array.from(await emps.active.keys());
-    await updatePrices(empAddresses).then((results) => {
+    await updateLatestPrices(empAddresses).then((results) => {
       results.forEach((result) => {
         if (result.status === "rejected") console.error("Error updating synthetic price: " + result.reason.message);
       });
     });
+    await updatePriceHistories(empAddresses).then((results) => {
+      results.forEach((result) => {
+        if (result.status === "rejected")
+          console.error("Error updating historical synthetic price: " + result.reason.message);
+      });
+    });
   }
 
   return {
     update,
     utils: {
-      updatePrice,
-      updatePrices,
+      getOrCreateHistoryTable,
+      getLatestPriceFromTable,
+      updatePriceHistories,
+      updatePriceHistory,
+      updateLatestPrice,
+      updateLatestPrices,
     },
   };
 }