rerun adapters

serverless.yml

@@ -155,6 +155,22 @@ functions:
     memorySize: 2000
     events:
       - schedule: cron(0 0 * * ? *)
+  runAdapterFromTo:
+    handler: src/handlers/runAdapterFromTo.default
+    timeout: 900
+    memorySize: 1024
+  runAllAdaptersHistorical:
+    handler: src/handlers/runAllAdaptersHistorical.default
+    timeout: 900
+    memorySize: 1024
+    events:
+      - schedule: cron(0 0,12 * * ? *)
+  dailyAggregateAllAdapters:
+    handler: src/handlers/dailyAggregateAllAdapters.default
+    timeout: 900
+    memorySize: 1024
+    events:
+      - schedule: cron(0 1 * * ? *)
 
 resources:
   # CORS for api gateway errors

src/handlers/dailyAggregateAllAdapters.ts

@@ -0,0 +1,22 @@
+import { wrapScheduledLambda } from "../utils/wrap";
+import { convertToUnixTimestamp } from "../utils/date";
+import { runAggregateDataHistorical } from "../utils/aggregate";
+import bridgeNetworkData from "../data/bridgeNetworkData";
+
+export default wrapScheduledLambda(async (_event) => {
+  const currentDate = new Date();
+  const yesterdayDate = new Date(currentDate);
+  yesterdayDate.setDate(currentDate.getDate() - 1);
+
+  const startOfYesterday = new Date(yesterdayDate.setUTCHours(0, 0, 0, 0));
+  const endOfYesterday = new Date(yesterdayDate.setUTCHours(23, 59, 59, 999));
+
+  const startTimestamp = convertToUnixTimestamp(startOfYesterday);
+  const endTimestamp = convertToUnixTimestamp(endOfYesterday);
+
+  console.log(`Aggregating data for ${startOfYesterday.toISOString()} to ${endOfYesterday.toISOString()}`);
+
+  for (const adapter of bridgeNetworkData) {
+    await runAggregateDataHistorical(startTimestamp, endTimestamp, adapter.id, false);
+  }
+});

src/handlers/runAdapterFromTo.ts

@@ -0,0 +1,59 @@
+import { wrapScheduledLambda } from "../utils/wrap";
+import bridgeNetworks from "../data/bridgeNetworkData";
+import { runAdapterHistorical } from "../utils/adapter";
+import { sql } from "../utils/db";
+import { Chain } from "@defillama/sdk/build/general";
+import { getBlockByTimestamp } from "../utils/blocks";
+
+const handler = async (event: any) => {
+  try {
+    const { bridgeName, fromTimestamp, toTimestamp } = event;
+
+    const adapter = bridgeNetworks.find((x) => x.bridgeDbName === bridgeName);
+    if (!adapter) throw new Error("Invalid adapter");
+
+    console.log(`Running adapter for ${bridgeName} from timestamp ${fromTimestamp} to ${toTimestamp}`);
+
+    const promises = adapter.chains.map(async (chain) => {
+      let nChain;
+      if (adapter.chainMapping && adapter.chainMapping[chain.toLowerCase()]) {
+        nChain = adapter.chainMapping[chain.toLowerCase()];
+      } else {
+        nChain = chain.toLowerCase();
+      }
+      if (nChain === adapter?.destinationChain?.toLowerCase()) return;
+
+      console.log(`Processing chain ${nChain} for ${bridgeName}`);
+
+      let fromBlock, toBlock;
+      if (bridgeName === "ibc") {
+        fromBlock = await getBlockByTimestamp(fromTimestamp, nChain as Chain, adapter, "First");
+        toBlock = await getBlockByTimestamp(toTimestamp, nChain as Chain, adapter, "Last");
+      } else {
+        fromBlock = await getBlockByTimestamp(fromTimestamp, nChain as Chain);
+        toBlock = await getBlockByTimestamp(toTimestamp, nChain as Chain);
+      }
+
+      if (!fromBlock || !toBlock) {
+        console.error(`Could not find blocks for ${nChain} on ${bridgeName}`);
+        return;
+      }
+
+      await runAdapterHistorical(fromBlock.block, toBlock.block, adapter.id, nChain, true, false, "upsert");
+
+      console.log(
+        `Adapter ${bridgeName} ran successfully for chain ${nChain} from block ${fromBlock.block} to ${toBlock.block}`
+      );
+    });
+
+    await Promise.all(promises);
+
+    console.log(`Adapter ${bridgeName} completed for all chains`);
+  } catch (e) {
+    console.error(`Adapter failed: ${JSON.stringify(e)}`);
+  } finally {
+    await sql.end();
+  }
+};
+
+export default wrapScheduledLambda(handler);

src/handlers/runAllAdaptersHistorical.ts

@@ -0,0 +1,45 @@
+import { wrapScheduledLambda } from "../utils/wrap";
+import bridgeNetworks from "../data/bridgeNetworkData";
+import aws from "aws-sdk";
+import { sql } from "../utils/db";
+
+async function invokeLambda(functionName: string, event: any) {
+  return new Promise((resolve, _reject) => {
+    new aws.Lambda().invoke(
+      {
+        FunctionName: functionName,
+        InvocationType: "Event",
+        Payload: JSON.stringify(event, null, 2),
+      },
+      function (error, data) {
+        console.log(error, data);
+        resolve(data);
+      }
+    );
+  });
+}
+
+const handler = async (event: any) => {
+  const now = Math.floor(Date.now() / 1000);
+  const oneDayAgo = now - 86400;
+  const halfDayAgo = now - 43200;
+
+  const timeRanges = [
+    { start: oneDayAgo, end: halfDayAgo },
+    { start: halfDayAgo, end: now },
+  ];
+
+  for (const timeRange of timeRanges) {
+    for (const bridge of bridgeNetworks) {
+      await invokeLambda("llama-bridges-prod-runAdapterFromTo", {
+        bridgeName: bridge.bridgeDbName,
+        fromTimestamp: timeRange.start,
+        toTimestamp: timeRange.end,
+      });
+    }
+  }
+
+  console.log("Initiated historical runs for all adapters");
+};
+
+export default wrapScheduledLambda(handler);