Pulling refs/heads/staging into test-staging

components/front-page/LatestTrades.tsx

@@ -68,7 +68,9 @@ const LatestTrades = ({
       ),
       outcome: trade.outcomeName,
       trade: trade.type === "buy" ? "Buy" : "Sell",
-      cost: formatNumberLocalized(trade.cost.div(ZTG).toNumber()),
+      cost: `${formatNumberLocalized(trade.cost.div(ZTG).toNumber())} ${
+        trade.costSymbol
+      }`,
       price: formatNumberLocalized(trade.outcomePrice.toNumber()),
       time: `${moment.duration(now.diff(trade.time)).humanize()} ago`,
     };

lib/gql/get-network-stats.ts

@@ -5,12 +5,13 @@ import { parseAssetIdString } from "lib/util/parse-asset-id";
 import { getBaseAssetHistoricalPrices, lookupPrice } from "./historical-prices";
 import {
   PoolOrderByInput,
+  NeoPoolOrderByInput,
   HistoricalSwapOrderByInput,
 } from "@zeitgeistpm/indexer";
 
 export const getNetworkStats = async (sdk: Sdk<FullContext>) => {
-  const [marketCountBN, basePrices, pools, historicalSwaps] = await Promise.all(
-    [
+  const [marketCountBN, basePrices, pools, neoPools, historicalSwaps] =
+    await Promise.all([
       sdk.api.query.marketCommons.marketCounter(),
       getBaseAssetHistoricalPrices(),
       fetchAllPages(async (pageNumber, limit) => {
@@ -21,6 +22,14 @@ export const getNetworkStats = async (sdk: Sdk<FullContext>) => {
         });
         return pools;
       }),
+      fetchAllPages(async (pageNumber, limit) => {
+        const { neoPools } = await sdk.indexer.neoPools({
+          limit: limit,
+          offset: pageNumber * limit,
+          order: NeoPoolOrderByInput.IdAsc,
+        });
+        return neoPools;
+      }),
       fetchAllPages(async (pageNumber, limit) => {
         const { historicalSwaps } = await sdk.indexer.historicalSwaps({
           limit: limit,
@@ -29,10 +38,23 @@ export const getNetworkStats = async (sdk: Sdk<FullContext>) => {
         });
         return historicalSwaps;
       }),
-    ],
-  );
+    ]);
+
+  const totalPoolVolumeUsd = pools.reduce<Decimal>((total, pool) => {
+    const poolCreationBaseAssetPrice = lookupPrice(
+      basePrices,
+      parseAssetIdString(pool.baseAsset) as BaseAssetId,
+      new Date(pool.createdAt).getTime(),
+    );
+
+    const volumeUsd = new Decimal(pool.volume).mul(
+      poolCreationBaseAssetPrice ?? 0,
+    );
+
+    return total.plus(volumeUsd);
+  }, new Decimal(0));
 
-  const totalVolumeUsd = pools.reduce<Decimal>((total, pool) => {
+  const totalNeopoolVolumeUsd = pools.reduce<Decimal>((total, pool) => {
     const poolCreationBaseAssetPrice = lookupPrice(
       basePrices,
       parseAssetIdString(pool.baseAsset) as BaseAssetId,
@@ -54,6 +76,9 @@ export const getNetworkStats = async (sdk: Sdk<FullContext>) => {
   return {
     marketCount: marketCountBN.toNumber(),
     tradersCount,
-    volumeUsd: totalVolumeUsd.div(ZTG).toNumber(),
+    volumeUsd: totalNeopoolVolumeUsd
+      .plus(totalPoolVolumeUsd)
+      .div(ZTG)
+      .toNumber(),
   };
 };

lib/gql/trending-markets.ts

@@ -1,15 +1,18 @@
-import { PoolOrderByInput, PoolStatus } from "@zeitgeistpm/indexer";
+import {
+  MarketOrderByInput,
+  MarketStatus,
+  ScoringRule,
+} from "@zeitgeistpm/indexer";
 import {
   BaseAssetId,
   FullContext,
   IOForeignAssetId,
-  ScalarRangeType,
   Sdk,
 } from "@zeitgeistpm/sdk";
-import { ZeitgeistPrimitivesMarketMarketCreation } from "@polkadot/types/lookup";
+import { isNotNull } from "@zeitgeistpm/utility/dist/null";
 import { IndexedMarketCardData } from "components/markets/market-card/index";
 import Decimal from "decimal.js";
-import { gql, GraphQLClient } from "graphql-request";
+import { GraphQLClient, gql } from "graphql-request";
 import { DAY_SECONDS, ZTG } from "lib/constants";
 import { hiddenMarketIds } from "lib/constants/markets";
 import {
@@ -21,17 +24,11 @@ import { getCurrentPrediction } from "lib/util/assets";
 import { fetchAllPages } from "lib/util/fetch-all-pages";
 import { parseAssetIdString } from "lib/util/parse-asset-id";
 import { marketMetaFilter } from "./constants";
-import { isNotNull } from "@zeitgeistpm/utility/dist/null";
 
 const poolChangesQuery = gql`
   query PoolChanges($start: DateTime, $end: DateTime) {
     historicalPools(
-      where: {
-        timestamp_gt: $start
-        volume_gt: "0"
-        event_contains: "Swap"
-        timestamp_lt: $end
-      }
+      where: { timestamp_gt: $start, volume_gt: "0", timestamp_lt: $end }
       orderBy: id_DESC
     ) {
       poolId
@@ -111,107 +108,74 @@ const getTrendingMarkets = async (
     end: now,
   });
 
-  const pools = await fetchAllPages(async (pageNumber, limit) => {
-    const { pools } = await sdk.indexer.pools({
+  const markets = await fetchAllPages(async (pageNumber, limit) => {
+    const { markets } = await sdk.indexer.markets({
       limit: limit,
       offset: pageNumber * limit,
-      where: { status_eq: PoolStatus.Active },
-      order: PoolOrderByInput.IdAsc,
+      order: MarketOrderByInput.IdDesc,
+      where: {
+        status_eq: MarketStatus.Active,
+        scoringRule_eq: ScoringRule.Lmsr,
+      },
     });
-    return pools;
+    return markets;
   });
 
   const basePrices = await getBaseAssetPrices(sdk);
 
-  const trendingPoolIds = calcTrendingPools(historicalPools, basePrices, pools);
-
-  const trendingMarkets = await Promise.all(
-    trendingPoolIds.map(async (poolId) => {
-      const marketsRes = await client.request<{
-        markets: {
-          marketId: number;
-          img: string;
-          question: string;
-          creation: ZeitgeistPrimitivesMarketMarketCreation["type"];
-          marketType: { [key: string]: string };
-          categories: { color: string; name: string }[];
-          outcomeAssets: string[];
-          baseAsset: string;
-          creator: string;
-          pool: {
-            volume: string;
-          };
-          tags: [];
-          status: string;
-          scalarType: ScalarRangeType;
-          period: { end: string };
-        }[];
-      }>(marketQuery, {
-        poolId: Number(poolId),
-      });
-
-      const market = marketsRes.markets[0];
-
-      if (!market) {
-        console.log("No market");
-        return null;
-      }
-
-      const assetsRes = await client.request<{
-        assets: {
-          pool: { poolId: number };
-          price: number;
-          assetId: string;
-        }[];
-      }>(assetsQuery, {
-        poolId: Number(poolId),
-      });
-
-      const assets = assetsRes.assets;
-
-      const prediction = getCurrentPrediction(assets, market);
+  const trendingMarketIds = calcTrendingMarkets(
+    historicalPools,
+    basePrices,
+    markets,
+  );
 
-      if (!market.categories) {
-        console.log("No categories for market", market.marketId);
-        return null;
-      }
+  const tm = trendingMarketIds.map((marketId) => {
+    const market = markets.find(
+      (market) => market.marketId === Number(marketId),
+    );
 
-      const marketCategories: MarketOutcomes = market.categories.map(
-        (category, index) => {
-          const asset = assets[index];
-          const marketCategory: MarketOutcome = {
-            ...category,
-            assetId: market.outcomeAssets[index],
-            price: asset.price,
-          };
+    if (!market || !market.categories) return;
+    const marketCategories: MarketOutcomes = market.categories.map(
+      (category, index) => {
+        const asset = market.assets[index];
 
-          return marketCategory;
-        },
-      );
+        const marketCategory: MarketOutcome = {
+          name: category.name ?? "",
+          assetId: market.outcomeAssets[index],
+          price: asset.price,
+        };
 
-      const trendingMarket: IndexedMarketCardData = {
-        marketId: market.marketId,
-        question: market.question,
-        creation: market.creation,
-        img: market.img,
-        prediction: prediction,
-        creator: market.creator,
-        volume: Number(new Decimal(market.pool.volume).div(ZTG).toFixed(0)),
-        baseAsset: market.baseAsset,
-        outcomes: marketCategories,
-        pool: market.pool ?? null,
-        marketType: market.marketType,
-        tags: market.tags,
-        status: market.status,
-        scalarType: market.scalarType,
-        endDate: market.period.end,
-      };
+        return marketCategory;
+      },
+    );
 
-      return trendingMarket;
-    }),
-  );
+    const prediction = getCurrentPrediction(market.assets, market);
+
+    const trendingMarket: IndexedMarketCardData = {
+      marketId: market.marketId,
+      question: market.question ?? "",
+      creation: market.creation,
+      img: market.img ?? "",
+      prediction: prediction,
+      creator: market.creator,
+      volume: Number(
+        new Decimal(market.neoPool?.volume ?? 0).div(ZTG).toFixed(0),
+      ),
+      baseAsset: market.baseAsset,
+      outcomes: marketCategories,
+      pool: market.pool ?? null,
+      neoPool: market.neoPool,
+      marketType: market.marketType as any,
+      tags: market.tags?.filter(isNotNull),
+      status: market.status,
+      scalarType: (market.scalarType ?? null) as "number" | "date" | null,
+      endDate: market.period.end,
+    };
+
+    return trendingMarket;
+  });
 
-  return trendingMarkets.filter(isNotNull);
+  return tm.filter(isNotNull);
 };
 
 const lookupPrice = (
@@ -223,46 +187,52 @@ const lookupPrice = (
     : basePrices["ztg"];
 };
 
-const calcTrendingPools = (
+const calcTrendingMarkets = (
   transactions: {
     poolId: number;
     dVolume: string;
   }[],
   basePrices: ForeignAssetPrices,
-  pools: { poolId: number; baseAsset: string; status: string }[],
+  markets: { marketId: number; baseAsset: string }[],
 ) => {
-  const poolVolumes: { [key: string]: Decimal } = {};
-  const maxPools = 8;
+  const marketVolumes: { [key: string]: Decimal } = {};
+  const maxMarkets = 8;
 
-  // find total volume for each pool
+  // find total volume for each market
   transactions.forEach((transaction) => {
-    const volume = poolVolumes[transaction.poolId];
-    if (volume) {
-      poolVolumes[transaction.poolId] = volume.plus(transaction.dVolume);
-    } else {
-      poolVolumes[transaction.poolId] = new Decimal(transaction.dVolume);
+    //for lsmr poolId === marketId
+    const marketId = transaction.poolId;
+
+    if (markets.some((market) => market.marketId === marketId)) {
+      const volume = marketVolumes[transaction.poolId];
+      if (volume) {
+        // for amm2 marketId === poolId
+        marketVolumes[transaction.poolId] = volume.plus(transaction.dVolume);
+      } else {
+        marketVolumes[transaction.poolId] = new Decimal(transaction.dVolume);
+      }
     }
   });
 
-  for (let poolId in poolVolumes) {
-    const base = pools.find((pool) => pool.poolId === Number(poolId))
+  for (let marketId in marketVolumes) {
+    const base = markets.find((market) => market.marketId === Number(marketId))
       ?.baseAsset;
 
     const value = lookupPrice(
       basePrices,
       parseAssetIdString(base) as BaseAssetId,
     );
 
-    poolVolumes[poolId] = poolVolumes[poolId].mul(value ?? 0);
+    marketVolumes[marketId] = marketVolumes[marketId].mul(value ?? 0);
   }
 
-  const poolIdsByVolumeDesc = Object.keys(poolVolumes).sort((a, b) => {
-    const aVol = poolVolumes[a];
-    const bVol = poolVolumes[b];
+  const marketIdsByVolumeDesc = Object.keys(marketVolumes).sort((a, b) => {
+    const aVol = marketVolumes[a];
+    const bVol = marketVolumes[b];
     return bVol.minus(aVol).toNumber();
   });
 
-  return poolIdsByVolumeDesc.splice(0, maxPools);
+  return marketIdsByVolumeDesc.splice(0, maxMarkets);
 };
 
 export default getTrendingMarkets;