v2 adapter, add isTBD and isIncentives

Author: ReynardoEW

protocols/spark.ts

@@ -51,7 +51,7 @@ const spark: Protocol = {
             "https://docs.spark.fi/governance/spk-token",
         ],
         notes: ["Sky Farming rewards are only counted when users have claimed them."],
-        token: "coingecko:spark",
+        token: "coingecko:spark-2",
         protocolIds: ["parent#spark"],
     },
     categories: {

types/adapters.ts

@@ -61,17 +61,17 @@ export type LinearAdapterResult = {
 };
 export type ChartData = {
   timestamps: number[];
-  unlocked: number[];      // Net value after burns
-  rawEmission: number[];   // Original emission without burns
-  burned: number[];        // Burn amounts
+  unlocked: number[];
+  rawEmission: number[];
+  burned: number[];
   isContinuous: boolean;
   apiData?: ApiChartData[];
 };
 export type ApiChartData = {
   timestamp: number;
-  unlocked: number;      // Net value after burns
-  rawEmission: number;   // Original emission without burns
-  burned: number;        // Burn amount
+  unlocked: number;
+  rawEmission: number;
+  burned: number;
   label?: string;
 };
 export type TransposedApiChartData = {
@@ -84,12 +84,20 @@ export type ChartYAxisData = {
   data: number[];
   end: number;
 };
-export type Protocol = {
+export type ProtocolV1 = {
   [section: string]: any;
   documented?: Documented;
   meta: Metadata;
   categories: { [key in SectionType]?: string[] | undefined };
 };
+
+export interface ProtocolV2 extends Record<string, any> {
+  meta: MetadataV2;
+  categories: Categories;
+  documented?: Documented;
+}
+
+export type Protocol = ProtocolV1 | ProtocolV2;
 export type Documented = {
   replaces: string[];
   [section: string]: any;
@@ -175,10 +183,10 @@ export type AllocationDetail = {
   recipient: string;
   category: string;
   unlockType: "cliff" | "linear_start" | "linear_rate_change";
-  amount?: number;  
+  amount?: number;
   previousRatePerWeek?: number;
   newRatePerWeek?: number;
-}
+};
 
 export type UnlockEvent = {
   timestamp: number;
@@ -188,8 +196,8 @@ export type UnlockEvent = {
     totalTokensCliff?: number;
     netChangeInWeeklyRate?: number;
     totalNewWeeklyRate?: number;
-  }
-}
+  };
+};
 
 export type TimeSeriesChainData = {
   [block: string]: {
@@ -199,4 +207,109 @@ export type TimeSeriesChainData = {
 };
 export type Allocations = { [category: string]: number };
 
-export type EmissionBreakdown = Record<string, { emission24h: number; emission7d: number; emission30d: number }>;
+export type EmissionBreakdown = Record<
+  string,
+  { emission24h: number; emission7d: number; emission30d: number }
+>;
+
+export interface MetadataV2 extends Metadata {
+  version: 2;
+}
+
+export interface SectionV2 {
+  displayName?: string;
+  methodology?: string;
+  isIncentive?: boolean;
+  isTBD?: boolean;
+  protocols?: string[];
+  components: ComponentV2[];
+}
+
+export interface ComponentV2 {
+  id: string;
+  name: string;
+  methodology?: string;
+  isIncentive?: boolean;
+  isTBD?: boolean;
+  protocols?: string[];
+  fetch: (backfill?: boolean) => Promise<AdapterResult[]>;
+  metadata?: ComponentMetadata;
+}
+
+export interface ComponentMetadata {
+  contract?: string;
+  eventSignature?: string;
+  [key: string]: any;
+}
+
+export type SectionV1Function = (
+  backfill?: boolean,
+) => Promise<AdapterResult[]> | AdapterResult[];
+export type SectionV1Array = (SectionV1Function | AdapterResult)[];
+
+export interface ComponentResult {
+  component: ComponentV2;
+  results: AdapterResult[];
+  flags: {
+    isIncentive: boolean;
+    isTBD: boolean;
+    protocols?: string[];
+  };
+}
+
+export interface ProcessedSectionV2 {
+  sectionName: string;
+  section: SectionV2;
+  components: ComponentResult[];
+  aggregatedResults: AdapterResult[];
+  hasIncentives: boolean;
+  hasTBD: boolean;
+}
+
+export interface ProcessedProtocolV2 {
+  protocol: ProtocolV2;
+  sections: ProcessedSectionV2[];
+  supplyMetrics: AdjustedSupplyMetrics;
+}
+
+export interface AdjustedSupplyMetrics {
+  maxSupply: number;
+  adjustedSupply: number;
+  tbdAmount: number;
+  incentiveAmount: number;
+  nonIncentiveAmount: number;
+}
+
+export interface ChartDataV2 extends ChartData {
+  components?: ComponentChartData[];
+  supplyMetrics?: AdjustedSupplyMetrics;
+}
+
+export interface ComponentChartData {
+  section: string;
+  component: string;
+  name: string;
+  data: ChartData;
+  flags: {
+    isIncentive: boolean;
+    isTBD: boolean;
+    protocols?: string[];
+  };
+  metadata?: {
+    methodology?: string;
+    [key: string]: any;
+  };
+}
+
+export function isProtocolV2(protocol: Protocol): protocol is ProtocolV2 {
+  return (protocol as any).meta?.version === 2;
+}
+
+export function isSectionV2(section: any): section is SectionV2 {
+  return (
+    section &&
+    typeof section === "object" &&
+    "components" in section &&
+    Array.isArray(section.components)
+  );
+}

utils/block.ts

@@ -28,9 +28,11 @@ export async function getBlock2(
   timestamp: number,
 ): Promise<number> {
   if (["polygon_zkevm", "vision", "era"].includes(chain))
-    return lookupBlock(timestamp, { chain }).then(blockData => blockData.block);
-  const res = await (await fetch(
-    `https://coins.llama.fi/block/${chain}/${timestamp}`,
-  )).json();
+    return lookupBlock(timestamp, { chain }).then(
+      (blockData) => blockData.block,
+    );
+  const res = await (
+    await fetch(`https://coins.llama.fi/block/${chain}/${timestamp}`)
+  ).json();
   return res.height;
 }

utils/categoryData.ts

@@ -69,7 +69,10 @@ export function createCategoryData(
       rawCurrentAllocations[c] += current;
       rawFinalAllocations[c] += final;
     });
-      progressAllocations[c] = calculateProgress(rawCurrentAllocations[c], rawFinalAllocations[c]);
+    progressAllocations[c] = calculateProgress(
+      rawCurrentAllocations[c],
+      rawFinalAllocations[c],
+    );
   });
 
   return {
@@ -79,9 +82,11 @@ export function createCategoryData(
   };
 }
 
-export function createSectionData(
-  data: ChartSection[]
-): { current: Allocations; final: Allocations, progress: Allocations } {
+export function createSectionData(data: ChartSection[]): {
+  current: Allocations;
+  final: Allocations;
+  progress: Allocations;
+} {
   if (!data.length) return { current: {}, final: {}, progress: {} };
   const rawCurrentAllocations: Allocations = {};
   const rawFinalAllocations: Allocations = {};
@@ -92,7 +97,7 @@ export function createSectionData(
     const s = section;
     if (!s) return;
     const currentEntryIndex = s.data.timestamps.findIndex(
-      (t: number) => timestampNow - RESOLUTION_SECONDS < t && t < timestampNow
+      (t: number) => timestampNow - RESOLUTION_SECONDS < t && t < timestampNow,
     );
     const finalEntryIndex = s.data.unlocked.length - 1;
     const current =

utils/chainCalls.ts

@@ -35,7 +35,7 @@ export function filterRawAmounts(
 
   const data = Object.values(chainData);
   for (let i = 0; i < data.length; i++) {
-    if (!('result' in data[i])) data[i].result = i > 0 ? data[i - 1].result : 0
+    if (!("result" in data[i])) data[i].result = i > 0 ? data[i - 1].result : 0;
     const thisBalance = data[i].result;
     if (depositIndex == 0 && thisBalance == 0) continue;
 

utils/clickhouse.ts

@@ -1,10 +1,14 @@
-import { ClickHouseClient, createClient, Row } from '@clickhouse/client';
-import { getEnv } from './env';
+import { ClickHouseClient, createClient, Row } from "@clickhouse/client";
+import { getEnv } from "./env";
 
 let client: ClickHouseClient | null = null;
 let connectionPromise: Promise<ClickHouseClient> | null = null;
 
-const requiredVars = ['CLICKHOUSE_HOST', 'CLICKHOUSE_USERNAME', 'CLICKHOUSE_PASSWORD'];
+const requiredVars = [
+  "CLICKHOUSE_HOST",
+  "CLICKHOUSE_USERNAME",
+  "CLICKHOUSE_PASSWORD",
+];
 
 export async function connectClickhouse() {
   if (client) {
@@ -16,37 +20,42 @@ export async function connectClickhouse() {
   }
 
   connectionPromise = (async () => {
-    const missingVars = requiredVars.filter(varName => !getEnv(varName));
+    const missingVars = requiredVars.filter((varName) => !getEnv(varName));
     if (missingVars.length) {
-      throw new Error(`Missing required environment variables: ${missingVars.join(', ')}`);
+      throw new Error(
+        `Missing required environment variables: ${missingVars.join(", ")}`,
+      );
     }
 
-    const url = `http://${getEnv('CLICKHOUSE_HOST')}:${getEnv('CLICKHOUSE_PORT')}`;
+    const url = `http://${getEnv("CLICKHOUSE_HOST")}:${getEnv("CLICKHOUSE_PORT")}`;
     client = createClient({
       url,
-      username: getEnv('CLICKHOUSE_USERNAME'),
-      password: getEnv('CLICKHOUSE_PASSWORD'),
+      username: getEnv("CLICKHOUSE_USERNAME"),
+      password: getEnv("CLICKHOUSE_PASSWORD"),
       keep_alive: { enabled: true, idle_socket_ttl: 300000 },
       compression: { response: true, request: false },
-      max_open_connections: 10
+      max_open_connections: 10,
     });
     return client;
   })();
 
   return connectionPromise;
 }
 
-export async function queryClickhouse<T extends Row>(sql: string, params?: Record<string, any>): Promise<T[]> {
+export async function queryClickhouse<T extends Row>(
+  sql: string,
+  params?: Record<string, any>,
+): Promise<T[]> {
   const client = await connectClickhouse();
   try {
-    const resultSet = await client.query({ 
-      query: sql, 
+    const resultSet = await client.query({
+      query: sql,
       query_params: params,
-      format: 'JSONEachRow'
+      format: "JSONEachRow",
     });
     return await resultSet.json<T>();
   } catch (error: any) {
-    if (error?.code === 'ECONNRESET' || error?.code === 'ECONNREFUSED') {
+    if (error?.code === "ECONNRESET" || error?.code === "ECONNREFUSED") {
       await disconnectClickhouse();
     }
     throw error;
@@ -59,4 +68,4 @@ export async function disconnectClickhouse() {
     client = null;
     connectionPromise = null;
   }
-}
+}