Add terminations tracking job

Author: lukasz-wal

src/blockchain/abis/client-abi.ts

@@ -0,0 +1,60 @@
+import { Abi } from "viem";
+
+export const CLIENT_CONTRACT_ABI = [
+  {
+    type: "function",
+    name: "getSPClients",
+    inputs: [
+      {
+        name: "provider",
+        type: "uint64",
+        internalType: "CommonTypes.FilActorId",
+      },
+    ],
+    outputs: [
+      {
+        name: "clients",
+        type: "address[]",
+        internalType: "address[]",
+      },
+    ],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    name: "getClientAllocationIdsPerProvider",
+    inputs: [
+      {
+        name: "provider",
+        type: "uint64",
+        internalType: "CommonTypes.FilActorId",
+      },
+      {
+        name: "client",
+        type: "address",
+        internalType: "address",
+      },
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint64[]",
+        internalType: "CommonTypes.FilActorId[]",
+      },
+    ],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    name: "claimsTerminatedEarly",
+    inputs: [
+      {
+        name: "claims",
+        type: "uint64[]",
+        internalType: "uint64[]",
+      },
+    ],
+    outputs: [],
+    stateMutability: "nonpayable",
+  },
+] as const satisfies Abi;

src/blockchain/abis/sla-allocator-abi.ts

@@ -1,6 +1,6 @@
 import { Abi } from "viem";
 
-export const SLA_ALLOCATOR_ABI = [
+export const SLA_ALLOCATOR_CONTRACT_ABI = [
   {
     type: "function",
     name: "providers",

src/blockchain/abis/sli-oracle-abi.ts

@@ -1,4 +1,4 @@
-export const SLI_ORACLE_ABI = [
+export const SLI_ORACLE_CONTRACT_ABI = [
   {
     type: "function",
     name: "setSLI",

src/blockchain/sla-allocator-contract.ts

@@ -1,25 +1,28 @@
 import { Address } from "viem";
 import { SERVICE_CONFIG } from "../config/env.js";
-import { logger } from "../utils/logger.js";
-import { SLA_ALLOCATOR_ABI } from "./abis/sla-allocator-abi.js";
+import { baseLogger } from "../utils/logger.js";
+import { SLA_ALLOCATOR_CONTRACT_ABI } from "./abis/sla-allocator-abi.js";
 import { getRpcClient } from "./blockchain-client.js";
 
+const childLogger = baseLogger.child(
+  { avengers: "assemble" },
+  { msgPrefix: "[SLA Allocator Contract] " },
+);
+
 export async function getProvidersFromSlaAllocatorContract(): Promise<
   number[]
 > {
   const rpcClient = getRpcClient();
 
-  logger.info("Fetching providers from SLA Allocator contract...");
+  childLogger.info("Fetching providers from contract...");
 
   const providers = await rpcClient.readContract({
     address: SERVICE_CONFIG.SLA_ALLOCATOR_CONTRACT_ADDRESS as Address,
-    abi: SLA_ALLOCATOR_ABI,
+    abi: SLA_ALLOCATOR_CONTRACT_ABI,
     functionName: "getProviders",
   });
 
-  logger.info(
-    `Fetched ${providers.length} providers from SLA Allocator contract`,
-  );
+  childLogger.info(`Fetched ${providers.length} providers from contract`);
 
   return providers.map((p) => Number(p));
 }

src/blockchain/sla-client-contract.ts

@@ -0,0 +1,94 @@
+import { Address } from "viem";
+import { SERVICE_CONFIG } from "../config/env.js";
+
+import { baseLogger } from "../utils/logger.js";
+import { CLIENT_CONTRACT_ABI } from "./abis/client-abi.js";
+import { getRpcClient, getWalletClient } from "./blockchain-client.js";
+
+const childLogger = baseLogger.child(
+  { avengers: "assemble" },
+  { msgPrefix: "[SLA Client Contract] " },
+);
+
+export async function getClientsForSPFromClientContract(
+  storageProviderId: number,
+): Promise<number[]> {
+  const rpcClient = getRpcClient();
+
+  childLogger.info("Fetching clients for storage provider...");
+
+  const spClients = await rpcClient.readContract({
+    address: SERVICE_CONFIG.CLIENT_CONTRACT_ADDRESS as Address,
+    abi: CLIENT_CONTRACT_ABI,
+    functionName: "getSPClients",
+    args: [BigInt(storageProviderId)],
+  });
+
+  childLogger.info(
+    `Fetched ${spClients.length} clients for SP ${storageProviderId}`,
+  );
+
+  return spClients.map((p) => Number(p));
+}
+
+export async function getClientAllocationIdsPerProvider(
+  storageProviderId: number,
+  clientAddresses: number[],
+): Promise<number[]> {
+  const rpcClient = getRpcClient();
+
+  childLogger.info(
+    `Fetching allocation ID for clients and storage providers ${storageProviderId}...`,
+  );
+
+  const multicallData = clientAddresses.map((clientId) => ({
+    address: SERVICE_CONFIG.CLIENT_CONTRACT_ADDRESS as Address,
+    abi: CLIENT_CONTRACT_ABI,
+    functionName: "getClientAllocationIdsPerProvider",
+    args: [storageProviderId, clientId],
+  }));
+
+  const multicall = await rpcClient.multicall({
+    contracts: multicallData,
+  });
+
+  childLogger.info(
+    `Fetched ${multicall.length} allocations for storage provider ${storageProviderId}...`,
+  );
+
+  return multicall.flat().map(Number);
+}
+
+export async function setClaimTerminatedEarly(allocationIds: bigint[]) {
+  const rpcClient = getRpcClient();
+  const walletClient = getWalletClient();
+
+  const oracleContractAddress =
+    SERVICE_CONFIG.ORACLE_CONTRACT_ADDRESS as Address;
+
+  childLogger.info("claimsTerminatedEarly: Simulating request...");
+
+  const { request } = await rpcClient.simulateContract({
+    address: oracleContractAddress,
+    abi: CLIENT_CONTRACT_ABI,
+    functionName: "claimsTerminatedEarly",
+    args: [allocationIds],
+    account: walletClient.account,
+  });
+
+  childLogger.info("claimsTerminatedEarly: Sending transaction...");
+
+  const txHash = await walletClient.writeContract(request);
+
+  childLogger.info(
+    `claimsTerminatedEarly: Transaction sent: ${txHash}, waiting for confirmation...`,
+  );
+
+  const receipt = await rpcClient.waitForTransactionReceipt({
+    hash: txHash,
+  });
+
+  childLogger.info(
+    `claimsTerminatedEarly: Transaction executed in block ${receipt.blockNumber}`,
+  );
+}

src/blockchain/sli-oracle-contract.ts

@@ -1,14 +1,19 @@
 import { Address, encodeFunctionData } from "viem";
 import { SERVICE_CONFIG } from "../config/env.js";
-import { logger } from "../utils/logger.js";
+import { baseLogger } from "../utils/logger.js";
 import {
   CdpSliResponse,
   SLIAttestation,
   StorageProvidersSLIMetric,
 } from "../utils/types.js";
-import { SLI_ORACLE_ABI } from "./abis/sli-oracle-abi.js";
+import { SLI_ORACLE_CONTRACT_ABI } from "./abis/sli-oracle-abi.js";
 import { getRpcClient, getWalletClient } from "./blockchain-client.js";
 
+const childLogger = baseLogger.child(
+  { avengers: "assemble" },
+  { msgPrefix: "[SLI Oracle Contract] " },
+);
+
 export async function setSliOnOracleContract(
   sliDataForProviders: CdpSliResponse[],
 ) {
@@ -22,7 +27,7 @@ export async function setSliOnOracleContract(
     provider: bigint;
     sli: SLIAttestation;
   }[] = sliDataForProviders.map((provider) => {
-    logger.info(
+    childLogger.info(
       `Preparing SLI data for provider ${provider.storageProviderId}`,
     );
     const availabilityMetric =
@@ -82,68 +87,73 @@ export async function setSliOnOracleContract(
 
   const encodedCalls = buildedSliData.map((req) =>
     encodeFunctionData({
-      abi: SLI_ORACLE_ABI,
+      abi: SLI_ORACLE_CONTRACT_ABI,
       functionName: "setSLI",
       args: [req.provider, req.sli],
     }),
   );
 
-  logger.info("Simulating request to oracle contract...");
+  childLogger.info("setSLI: Simulating request...");
 
   const { request } = await rpcClient.simulateContract({
     address: oracleContractAddress,
-    abi: SLI_ORACLE_ABI,
+    abi: SLI_ORACLE_CONTRACT_ABI,
     functionName: "multicall",
     args: [encodedCalls],
     account: walletClient.account,
   });
 
-  logger.info("Simulation successful.");
-
-  logger.info("Sending transaction to oracle contract...");
+  childLogger.info("setSLI: Sending transaction...");
 
   const txHash = await walletClient.writeContract(request);
 
-  logger.info(`Transaction sent: ${txHash}`);
-  logger.info(`Waiting for confirmation...`);
+  childLogger.info(
+    `setSLI: Transaction sent: ${txHash}, waiting for confirmation...`,
+  );
 
   const receipt = await rpcClient.waitForTransactionReceipt({
     hash: txHash,
   });
 
-  logger.info(`Transaction executed in block ${receipt.blockNumber}`);
+  childLogger.info(
+    `setSLI: Transaction executed in block ${receipt.blockNumber}`,
+  );
 }
 
 export async function getSPEmptyAttestations(): Promise<void> {
   const rpcClient = getRpcClient();
 
-  logger.info(
+  childLogger.info(
     "Fetching Attestations from SLI Oracle contract for SP: f03315260",
   );
 
   const providers = await rpcClient.readContract({
     address: SERVICE_CONFIG.ORACLE_CONTRACT_ADDRESS as Address,
-    abi: SLI_ORACLE_ABI,
+    abi: SLI_ORACLE_CONTRACT_ABI,
     functionName: "attestations",
     args: [90999],
   });
 
-  logger.info(`Fetched Attestation from SLI Oracle contract: ` + providers);
+  childLogger.info(
+    `Fetched Attestation from SLI Oracle contract: ` + providers,
+  );
 }
 
 export async function getSPFillAttestations(): Promise<void> {
   const rpcClient = getRpcClient();
 
-  logger.info(
+  childLogger.info(
     "Fetching Attestations from SLI Oracle contract for SP: f03315260",
   );
 
   const providers = await rpcClient.readContract({
     address: SERVICE_CONFIG.ORACLE_CONTRACT_ADDRESS as Address,
-    abi: SLI_ORACLE_ABI,
+    abi: SLI_ORACLE_CONTRACT_ABI,
     functionName: "attestations",
     args: [3315260],
   });
 
-  logger.info(`Fetched Attestations from SLI Oracle contract: ` + providers);
+  childLogger.info(
+    `Fetched Attestations from SLI Oracle contract: ` + providers,
+  );
 }

src/config/env.ts

@@ -11,6 +11,7 @@ export const EnvKeys = {
   CDP_SERVICE_URL: "CDP_SERVICE_URL",
   JOB_TRIGGER_AUTH_TOKEN: "JOB_TRIGGER_AUTH_TOKEN",
   APP_PORT: "APP_PORT",
+  CLIENT_CONTRACT_ADDRESS: "CLIENT_CONTRACT_ADDRESS",
 } as const;
 
 type EnvKey = (typeof EnvKeys)[keyof typeof EnvKeys];
@@ -27,4 +28,5 @@ export const SERVICE_CONFIG: Record<EnvKey, string> = {
   CDP_SERVICE_URL: process.env.CDP_SERVICE_URL || "",
   JOB_TRIGGER_AUTH_TOKEN: process.env.JOB_TRIGGER_AUTH_TOKEN || "",
   APP_PORT: process.env.APP_PORT || "3000",
+  CLIENT_CONTRACT_ADDRESS: process.env.CLIENT_CONTRACT_ADDRESS || "",
 };

src/http-server/server.ts

@@ -3,7 +3,7 @@ import express, { NextFunction, Request, Response } from "express";
 // import { setSliOracleJob } from "../jobs/set-sli-job.js";
 import { SERVICE_CONFIG } from "../config/env.js";
 import { setSliOracleJob } from "../jobs/set-sli-job.js";
-import { logger } from "../utils/logger.js";
+import { baseLogger } from "../utils/logger.js";
 
 const app = express();
 
@@ -18,7 +18,7 @@ function authMiddleware(req: Request, res: Response, next: NextFunction) {
   const authHeader = req.headers["authorization"];
 
   if (!AUTH_TOKEN) {
-    logger.warn("Missing JOB_TRIGGER_TOKEN env variable — skipping auth");
+    baseLogger.warn("Missing JOB_TRIGGER_TOKEN env variable — skipping auth");
     return next();
   }
 
@@ -38,26 +38,23 @@ app.post(
   "/trigger-now",
   authMiddleware,
   async (req: Request, res: Response) => {
-    logger.info("Manual trigger received via /trigger-now");
+    baseLogger.info("Manual trigger received via /trigger-now");
 
     try {
-      // await getSPEmptyAttestations();
-
       await setSliOracleJob();
 
-      // await getSPFillAttestations();
       res.json({ status: "ok", message: "Job triggered successfully" });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      logger.error(`Manual job trigger failed: ${message}`);
+      baseLogger.error(`Manual job trigger failed: ${message}`);
       res.status(500).json({ error: message });
     }
   },
 );
 
 app.listen(port, () => {
-  logger.info("Oracle service started on port " + port);
-  logger.info(`Health/trigger server running on port ${port}`);
-  logger.info(`Health endpoint: GET /health`);
-  logger.info(`Manual trigger:  POST /trigger-now`);
+  baseLogger.info("Oracle service started on port " + port);
+  baseLogger.info(`Health/trigger server running on port ${port}`);
+  baseLogger.info(`Health endpoint: GET /health`);
+  baseLogger.info(`Manual trigger:  POST /trigger-now`);
 });