Adjust SLIs from CDP enpoint

Author: lukasz-wal

src/blockchain/sli-oracle-contract.ts

@@ -1,7 +1,11 @@
 import { Address, encodeFunctionData } from "viem";
 import { SERVICE_CONFIG } from "../config/env.js";
 import { logger } from "../utils/logger.js";
-import { CdpSliResponse } from "../utils/types.js";
+import {
+  CdpSliResponse,
+  SLIAttestation,
+  StorageProvidersSLIMetric,
+} from "../utils/types.js";
 import { SLI_ORACLE_ABI } from "./abis/sli-oracle-abi.js";
 import { getRpcClient, getWalletClient } from "./blockchain-client.js";
 
@@ -14,7 +18,40 @@ export async function setSliOnOracleContract(
   const oracleContractAddress =
     SERVICE_CONFIG.ORACLE_CONTRACT_ADDRESS as Address;
 
-  const encodedCalls = sliDataForProviders.map((req) =>
+  const buildedSliData: {
+    provider: bigint;
+    sli: SLIAttestation;
+  }[] = sliDataForProviders.map((provider) => {
+    logger.info(
+      `Preparing SLI data for provider ${provider.storageProviderId}`,
+    );
+    const data = {
+      provider: provider.storageProviderId.startsWith("f0")
+        ? BigInt(provider.storageProviderId.slice(2))
+        : BigInt(provider.storageProviderId),
+      sli: {
+        availability:
+          Number(
+            provider.data
+              .find(
+                (d) =>
+                  d.sliMetric === StorageProvidersSLIMetric.RPA_RETRIEVABILITY,
+              )
+              ?.sliMetricValue?.split(".")[0],
+          ) || 0,
+        latency: 0,
+        indexing: 0,
+        retention: 0,
+        bandwidth: 0,
+        stability: 0,
+        lastUpdate: BigInt(provider.updatedAt.getTime()),
+      },
+    };
+
+    return data;
+  });
+
+  const encodedCalls = buildedSliData.map((req) =>
     encodeFunctionData({
       abi: SLI_ORACLE_ABI,
       functionName: "setSLI",
@@ -24,23 +61,26 @@ export async function setSliOnOracleContract(
 
   logger.info("Simulating request to oracle contract...");
 
-  const { request } = await rpcClient.simulateContract({
+  // const { request } =
+  await rpcClient.simulateContract({
     address: oracleContractAddress,
     abi: SLI_ORACLE_ABI,
     functionName: "multicall",
     args: [encodedCalls],
     account: walletClient.account,
   });
 
-  logger.info("Sending transaction to oracle contract...");
+  logger.info("Simulation successful.");
 
-  const txHash = await walletClient.writeContract(request);
+  // logger.info("Sending transaction to oracle contract...");
 
-  logger.info(`Transaction sent: ${txHash}, waiting for confirmation...`);
+  // const txHash = await walletClient.writeContract(request);
 
-  const receipt = await rpcClient.waitForTransactionReceipt({
-    hash: txHash,
-  });
+  // logger.info(`Transaction sent: ${txHash}, waiting for confirmation...`);
+
+  // const receipt = await rpcClient.waitForTransactionReceipt({
+  //   hash: txHash,
+  // });
 
-  logger.info(`Transaction executed in block ${receipt.blockNumber}`);
+  // logger.info(`Transaction executed in block ${receipt.blockNumber}`);
 }

src/http-server/server.ts

@@ -3,6 +3,7 @@ import express, { Request, Response, NextFunction } from "express";
 // import { setSliOracleJob } from "../jobs/set-sli-job.js";
 import { logger } from "../utils/logger.js";
 import { SERVICE_CONFIG } from "../config/env.js";
+import { setSliOracleJob } from "../jobs/set-sli-job.js";
 
 const app = express();
 
@@ -40,7 +41,7 @@ app.post(
     logger.info("Manual trigger received via /trigger-now");
 
     try {
-      // await setSliOracleJob();
+      await setSliOracleJob();
       res.json({ status: "ok", message: "Job triggered successfully" });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);

src/jobs/set-sli-job.ts

@@ -1,15 +1,51 @@
 import { getProvidersFromSlaAllocatorContract } from "../blockchain/sla-allocator-contract.js";
+import { setSliOnOracleContract } from "../blockchain/sli-oracle-contract.js";
+import { getSliForStorageProviders } from "../services/cdp-fetch-service.js";
 import { logger } from "../utils/logger.js";
 
 export async function setSliOracleJob() {
   logger.info("Oracle job started");
 
   try {
-    await getProvidersFromSlaAllocatorContract(); // TODO: enable when SLA Allocator is ready
-    // const sliDataForProviders = await getSliForStorageProviders(
-    //   slaContractProviders.map(String),
-    // ); // TODO: enable when CDP service is ready
-    //await setSliOnOracleContract(sliDataForProviders);
+    const slaContractProviders = await getProvidersFromSlaAllocatorContract();
+
+    if (slaContractProviders.length === 0) {
+      logger.info(
+        "No storage providers found in SLA Allocator contract, skipping SLI update on oracle contract",
+      );
+      return;
+    }
+
+    const sliDataForProviders = await getSliForStorageProviders(
+      slaContractProviders.map((sp) => `f0${sp.toString()}`),
+    );
+
+    if (sliDataForProviders.length === 0) {
+      logger.info(
+        "No SLI data fetched for any provider from CDP, skipping SLI update on oracle contract",
+      );
+      return;
+    }
+
+    // const sliDataForProviders: CdpSliResponse[] = [
+    //   {
+    //     storageProviderId: "f03315260",
+    //     storageProviderName: "ProviderOne",
+    //     updatedAt: new Date(),
+    //     data: [
+    //       {
+    //         sliMetric: StorageProvidersSLIMetric.RPA_RETRIEVABILITY,
+    //         sliMetricName: "RPA Retrievability",
+    //         sliMetricValue: "99.12",
+    //         sliMetricDescription: "Retrievability percentage",
+    //         sliMetricUnit: "percent",
+    //         updatedAt: new Date(),
+    //       },
+    //     ],
+    //   },
+    // ];
+
+    await setSliOnOracleContract(sliDataForProviders);
   } catch (err) {
     logger.error({ err }, "Oracle job failed");
   }

src/services/cdp-fetch-service.ts

@@ -17,11 +17,18 @@ async function fetchDataFromCdp(endpoint: string): Promise<CdpSliResponse[]> {
   return data;
 }
 
-export async function getSliForStorageProviders(storageProviders: string[]) {
+export async function getSliForStorageProviders(
+  storageProviders: string[],
+): Promise<CdpSliResponse[]> {
+  if (storageProviders.length === 0) {
+    logger.info("No storage providers provided for SLI fetch");
+    return [];
+  }
+
   const providersParam = storageProviders.join(",");
-  const endpoint = `sli-storage-providers/?providers=${encodeURIComponent(
+  const endpoint = `storage-providers/sli-data?storageProvidersIds=${encodeURIComponent(
     providersParam,
-  )}`; //TODO: adjust enpoint if needed
+  )}`;
 
   logger.info("Fetching SLI data from CDP service...");
 

src/utils/types.ts

@@ -8,7 +8,22 @@ export interface SLIAttestation {
   stability: number;
 }
 
+export enum StorageProvidersSLIMetric {
+  RPA_RETRIEVABILITY = "RPA_RETRIEVABILITY",
+}
+
+export interface StorageProvidersSLIData {
+  sliMetric: StorageProvidersSLIMetric;
+  sliMetricName: string;
+  sliMetricValue: string;
+  sliMetricDescription: string;
+  sliMetricUnit: string;
+  updatedAt: Date;
+}
+
 export interface CdpSliResponse {
-  provider: bigint;
-  sli: SLIAttestation;
+  storageProviderId: string;
+  storageProviderName: string | null;
+  updatedAt: Date;
+  data: StorageProvidersSLIData[];
 }