Feature: Price Tokens on Swap

package.json

@@ -8,7 +8,9 @@
     "dev": "envio dev",
     "codegen": "envio codegen",
     "start": "ts-node generated/src/Index.bs.js",
-    "test": "mocha --recursive --require ts-node/register \"test/**/*.ts\" --timeout 30000",
+    "dottest": "mocha -w --recursive -R dot --require ts-node/register \"test/**/*.ts\" --timeout 30000",
+    "test": "mocha --recursive --R spec --require ts-node/register \"test/**/*.ts\" --timeout 30000",
+    "test-watch": "mocha -w --recursive --R dot --require ts-node/register \"test/**/*.ts\" --timeout 30000",
     "enable-hydra": "./hack/hydra-mode/hydra-mode.sh"
   },
   "devDependencies": {

src/EventHandlers/CLPool.ts

@@ -12,7 +12,7 @@ import {
   LiquidityPoolAggregator,
   Token,
 } from "generated";
-import { set_whitelisted_prices } from "../PriceOracle";
+import { refreshTokenPrice, set_whitelisted_prices } from "../PriceOracle";
 import { normalizeTokenAmountTo1e18 } from "../Helpers";
 import { multiplyBase1e18, abs } from "../Maths";
 import { updateLiquidityPoolAggregator } from "../Aggregators/LiquidityPoolAggregator";
@@ -472,6 +472,7 @@ CLPool.Swap.handlerWithLoader({
     return { liquidityPoolAggregator, token0Instance, token1Instance };
   },
   handler: async ({ event, context, loaderReturn }) => {
+    const blockDatetime = new Date(event.block.timestamp * 1000);
     const entity: CLPool_Swap = {
       id: `${event.chainId}_${event.block.number}_${event.logIndex}`,
       sender: event.params.sender,
@@ -482,14 +483,16 @@ CLPool.Swap.handlerWithLoader({
       liquidity: event.params.liquidity,
       tick: event.params.tick,
       sourceAddress: event.srcAddress,
-      timestamp: new Date(event.block.timestamp * 1000),
+      timestamp: blockDatetime,
       chainId: event.chainId,
     };
 
     context.CLPool_Swap.set(entity);
 
     if (loaderReturn && loaderReturn.liquidityPoolAggregator) {
       const { liquidityPoolAggregator, token0Instance, token1Instance } = loaderReturn;
+      let token0 = token0Instance;
+      let token1 = token1Instance;
 
       // Delta that will be added to the liquidity pool aggregator
       let tokenUpdateData = {
@@ -503,25 +506,27 @@ CLPool.Swap.handlerWithLoader({
       tokenUpdateData.netAmount0 = abs(event.params.amount0);
       tokenUpdateData.netAmount1 = abs(event.params.amount1); 
 
-      if (token0Instance) {
+      if (token0) {
+        token0 = await refreshTokenPrice(token0, event.block.number, event.block.timestamp, event.chainId, context);
         const normalizedAmount0 = normalizeTokenAmountTo1e18(
           abs(event.params.amount0),
-          Number(token0Instance.decimals)
+          Number(token0.decimals)
         );
         tokenUpdateData.netVolumeToken0USD = multiplyBase1e18(
           normalizedAmount0,
-          token0Instance.pricePerUSDNew
+          token0.pricePerUSDNew
         );
       }
 
-      if (token1Instance) {
+      if (token1) {
+        token1 = await refreshTokenPrice(token1, event.block.number, event.block.timestamp, event.chainId, context);
         const normalizedAmount1 = normalizeTokenAmountTo1e18(
           abs(event.params.amount1),
-          Number(token1Instance.decimals)
+          Number(token1.decimals)
         );
         tokenUpdateData.netVolumeToken1USD = multiplyBase1e18(
           normalizedAmount1,
-          token1Instance.pricePerUSDNew
+          token1.pricePerUSDNew
         );
       }
 
@@ -534,8 +539,8 @@ CLPool.Swap.handlerWithLoader({
       const reserveResult = updateCLPoolLiquidity(
         liquidityPoolAggregator,
         event,
-        token0Instance,
-        token1Instance
+        token0,
+        token1
       );
 
       const liquidityPoolAggregatorDiff: Partial<LiquidityPoolAggregator> = {
@@ -558,21 +563,10 @@ CLPool.Swap.handlerWithLoader({
       updateLiquidityPoolAggregator(
         liquidityPoolAggregatorDiff,
         liquidityPoolAggregator,
-        new Date(event.block.timestamp * 1000),
-        context
-      );
-    }
-
-    const blockDatetime = new Date(event.block.timestamp * 1000);
-    try {
-      await set_whitelisted_prices(
-        event.chainId,
-        event.block.number,
         blockDatetime,
         context
       );
-    } catch (error) {
-      console.log(`Error updating token prices on CLPool swap on chain ${event.chainId}:`, error);
     }
+
   },
 });

src/EventHandlers/Pool.ts

@@ -3,7 +3,7 @@ import { Pool, Pool_Swap, Pool_Sync, Pool_Mint, Pool_Burn } from "generated";
 import { LiquidityPoolAggregator, User } from "./../src/Types.gen";
 import { normalizeTokenAmountTo1e18 } from "./../Helpers";
 import { abs, multiplyBase1e18 } from "./../Maths";
-import { set_whitelisted_prices } from "../PriceOracle";
+import { refreshTokenPrice } from "../PriceOracle";
 import { updateLiquidityPoolAggregator } from "../Aggregators/LiquidityPoolAggregator";
 import { TokenIdByChain } from "../Constants";
 
@@ -143,6 +143,8 @@ Pool.Swap.handlerWithLoader({
     };
   },
   handler: async ({ event, context, loaderReturn }) => {
+    const blockDatetime = new Date(event.block.timestamp * 1000);
+
     const entity: Pool_Swap = {
       id: `${event.chainId}_${event.block.number}_${event.logIndex}`,
       sender: event.params.sender,
@@ -152,7 +154,7 @@ Pool.Swap.handlerWithLoader({
       amount0Out: event.params.amount0Out,
       amount1Out: event.params.amount1Out,
       sourceAddress: event.srcAddress, // Add sourceAddress
-      timestamp: new Date(event.block.timestamp * 1000), // Convert to Date
+      timestamp: blockDatetime, // Convert to Date
       chainId: event.chainId,
     };
 
@@ -161,6 +163,9 @@ Pool.Swap.handlerWithLoader({
       const { liquidityPoolAggregator, token0Instance, token1Instance, to_address, user } =
         loaderReturn;
 
+      let token0 = token0Instance;
+      let token1 = token1Instance;
+
       let tokenUpdateData = {
         netAmount0: 0n,
         netAmount1: 0n,
@@ -170,26 +175,28 @@ Pool.Swap.handlerWithLoader({
       };
 
       tokenUpdateData.netAmount0 = event.params.amount0In + event.params.amount0Out;
-      if (token0Instance) {
+      if (token0) {
+        token0 = await refreshTokenPrice(token0, event.block.number, event.block.timestamp, event.chainId, context);
         const normalizedAmount0 = normalizeTokenAmountTo1e18(
           event.params.amount0In + event.params.amount0Out,
-          Number(token0Instance.decimals)
+          Number(token0.decimals)
         );
         tokenUpdateData.netVolumeToken0USD = multiplyBase1e18(
           normalizedAmount0,
-          token0Instance.pricePerUSDNew
+          token0.pricePerUSDNew
         );
       }
 
       tokenUpdateData.netAmount1 = event.params.amount1In + event.params.amount1Out;
-      if (token1Instance) {
+      if (token1) {
+        token1 = await refreshTokenPrice(token1, event.block.number, event.block.timestamp, event.chainId, context);
         const normalizedAmount1 = normalizeTokenAmountTo1e18(
           event.params.amount1In + event.params.amount1Out,
-          Number(token1Instance.decimals)
+          Number(token1.decimals)
         );
         tokenUpdateData.netVolumeToken1USD = multiplyBase1e18(
           normalizedAmount1,
-          token1Instance.pricePerUSDNew
+          token1.pricePerUSDNew
         );
       }
 
@@ -220,14 +227,13 @@ Pool.Swap.handlerWithLoader({
         context
       );
 
-      const blockDatetime = new Date(event.block.timestamp * 1000);
 
       // Update user and  create if they don't exist
       if (!user) {
         let newUser: User = {
           id: to_address,
           numberOfSwaps: 1n,
-          joined_at_timestamp: new Date(event.block.timestamp * 1000),
+          joined_at_timestamp: blockDatetime,
         };
         context.User.set(newUser);
       } else {
@@ -236,28 +242,16 @@ Pool.Swap.handlerWithLoader({
           numberOfSwaps: user.numberOfSwaps + 1n,
           joined_at_timestamp:
             user.joined_at_timestamp <
-            new Date(event.block.timestamp * 1000)
+            blockDatetime
               ? user.joined_at_timestamp
-              : new Date(event.block.timestamp * 1000),
+              : blockDatetime,
         }; // for unordered head mode this correctly categorizes base users who may have joined early on optimism.
         try {
           context.User.set(existingUser);
         } catch (error) {
           console.log("Error updating user:", error);
         }
       }
-
-      // Try to set prices
-      try {
-        await set_whitelisted_prices(
-          event.chainId,
-          event.block.number,
-          blockDatetime,
-          context
-        );
-      } catch (error) {
-        console.log("Error updating token prices on pool sync:", error);
-      }
     }
   },
 });
@@ -286,6 +280,7 @@ Pool.Sync.handlerWithLoader({
   },
   handler: async ({ event, context, loaderReturn }) => {
     if (!loaderReturn) return;
+    const blockDatetime = new Date(event.block.timestamp * 1000);
 
     const { liquidityPoolAggregator, token0Instance, token1Instance } = loaderReturn;
 
@@ -294,7 +289,7 @@ Pool.Sync.handlerWithLoader({
       reserve0: event.params.reserve0,
       reserve1: event.params.reserve1,
       sourceAddress: event.srcAddress,
-      timestamp: new Date(event.block.timestamp * 1000),
+      timestamp: blockDatetime,
       chainId: event.chainId,
     };
 
@@ -313,7 +308,7 @@ Pool.Sync.handlerWithLoader({
     if (token0Instance) {
       tokenUpdateData.normalizedReserve0 += normalizeTokenAmountTo1e18(
         event.params.reserve0,
-        Number(token0Instance?.decimals || 18)
+        Number(token0Instance.decimals)
       );
       tokenUpdateData.token0PricePerUSDNew = token0Instance.pricePerUSDNew;
       tokenUpdateData.totalLiquidityUSD += multiplyBase1e18(
@@ -325,8 +320,8 @@ Pool.Sync.handlerWithLoader({
     if (token1Instance) {
       tokenUpdateData.normalizedReserve1 += normalizeTokenAmountTo1e18(
         event.params.reserve1,
-        Number(token1Instance?.decimals || 18)
-    );
+        Number(token1Instance.decimals)
+      );
 
       tokenUpdateData.token1PricePerUSDNew = token1Instance.pricePerUSDNew;
       tokenUpdateData.totalLiquidityUSD += multiplyBase1e18(
@@ -341,7 +336,7 @@ Pool.Sync.handlerWithLoader({
       totalLiquidityUSD: tokenUpdateData.totalLiquidityUSD || liquidityPoolAggregator.totalLiquidityUSD,
       token0Price: tokenUpdateData.token0PricePerUSDNew,
       token1Price: tokenUpdateData.token1PricePerUSDNew,
-      lastUpdatedTimestamp: new Date(event.block.timestamp * 1000),
+      lastUpdatedTimestamp: blockDatetime,
     };
 
     updateLiquidityPoolAggregator(

src/PriceOracle.ts

@@ -15,6 +15,30 @@ export interface TokenPriceData {
   decimals: bigint;
 }
 
+const ONE_HOUR_MS = 60 * 60 * 1000; // 1 hour in milliseconds
+
+export async function refreshTokenPrice(
+  token: Token,
+  blockNumber: number,
+  blockTimestamp: number,
+  chainId: number,
+  context: any
+): Promise<Token> {
+  if (blockTimestamp - token.lastUpdatedTimestamp.getTime() < ONE_HOUR_MS) {
+    return token;
+  }
+
+  const tokenPriceData = await getTokenPriceData(token.address, blockNumber, chainId);
+  const updatedToken: Token = {
+    ...token,
+    pricePerUSDNew: tokenPriceData.pricePerUSDNew,
+    decimals: tokenPriceData.decimals,
+    lastUpdatedTimestamp: new Date(blockTimestamp * 1000)
+  };
+  context.Token.set(updatedToken);
+  return updatedToken;
+}
+
 export async function getTokenPriceData(tokenAddress: string, blockNumber: number, chainId: number): Promise<TokenPriceData> {
   const tokenDetails = await getErc20TokenDetails(
     tokenAddress,

test/EventHandlers/CLPool/CLPool.test.ts

@@ -14,7 +14,7 @@ import { setupCommon } from "../Pool/common";
 describe("CLPool Event Handlers", () => {
   let mockDb: any;
   let updateLiquidityPoolAggregatorStub: sinon.SinonStub;
-  let setPricesStub: sinon.SinonStub;
+  let mockPriceOracle: sinon.SinonStub;
 
   beforeEach(() => {
     mockDb = MockDb.createMockDb();
@@ -23,9 +23,11 @@ describe("CLPool Event Handlers", () => {
       LiquidityPoolAggregatorFunctions,
       "updateLiquidityPoolAggregator"
     );
-    setPricesStub = sinon
-      .stub(PriceOracle, "set_whitelisted_prices")
-      .resolves();
+    mockPriceOracle = sinon
+      .stub(PriceOracle, "refreshTokenPrice")
+      .callsFake(async (...args) => {
+        return args[0]; // Return the token that was passed in
+      });
 
   });
 
@@ -480,15 +482,13 @@ describe("CLPool Event Handlers", () => {
         const [diff] = aggregatorCalls;
         expect(diff.totalLiquidityUSD).to.equal(expectations.totalLiquidityUSD);
       });
-
-      it("should call set_whitelisted_prices", async () => {
-        expect(setPricesStub.calledOnce).to.be.true;
-        const [chainId, blockNumber, blockDatetime] =
-          setPricesStub.firstCall.args;
-
-        expect(chainId).to.equal(1);
-        expect(blockNumber).to.equal(123456);
-        expect(blockDatetime).to.deep.equal(new Date(1000000 * 1000));
+      it("should call refreshTokenPrice on token0", () => {
+        const calledToken = mockPriceOracle.firstCall.args[0];
+        expect(calledToken.address).to.equal(mockToken0Data.address);
+      });
+      it("should call refreshTokenPrice on token1", () => {
+        const calledToken = mockPriceOracle.secondCall.args[0];
+        expect(calledToken.address).to.equal(mockToken1Data.address);
       });
     });