@across-protocol/sdk 4.1.21 → 4.1.22

package/src/addressAggregator/adapters/util.ts

@@ -0,0 +1,47 @@
+import axios from "axios";
+import { Logger } from "../../utils";
+
+export { Logger } from "../../utils";
+
+const { ACROSS_USER_AGENT = "across-protocol" } = process.env;
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+export function logError(name: string, error: unknown, logger?: Logger): Promise<string[]> {
+  let reason: string;
+  if (error instanceof Error) {
+    reason = error.message;
+  } else {
+    reason = typeof error === "string" ? error : "unknown error";
+  }
+
+  logger?.warn({
+    at: `${name}::update`,
+    message: `Failed to read addresses from ${name}.`,
+    reason,
+  });
+  return Promise.resolve([]);
+}
+
+export async function fetch(name: string, url: string, timeout = 2000, retries = 1): Promise<unknown> {
+  const args = {
+    headers: { "User-Agent": ACROSS_USER_AGENT },
+    timeout,
+  };
+
+  const errs: string[] = [];
+  let tries = 0;
+  do {
+    try {
+      return (await axios(url, args)).data;
+    } catch (err) {
+      const errMsg = axios.isAxiosError(err) || err instanceof Error ? err.message : "unknown error";
+      errs.push(errMsg);
+      if (++tries <= retries) await sleep(Math.pow(1.5, tries) * 1000); // simple backoff
+    }
+  } while (tries <= retries);
+
+  throw new Error(`${name} retrieval failure (${errs.join(", ")})`);
+}

package/src/addressAggregator/index.ts

@@ -0,0 +1,86 @@
+import { utils as ethersUtils } from "ethers";
+import { Logger, mapAsync } from "../utils";
+import { AddressListAdapter, INVALID_ADDRESS } from "./types";
+import * as adapters from "./adapters";
+
+export * as adapters from "./adapters";
+
+export class AddressAggregator {
+  constructor(
+    readonly adapters: AddressListAdapter[],
+    protected readonly logger?: Logger
+  ) {}
+
+  static sources(): string[] {
+    return Object.keys(adapters);
+  }
+
+  async update(): Promise<Set<string>> {
+    this.logger?.debug({
+      at: "AddressAggregator::update",
+      message: "Updating addresses.",
+      sources: this.adapters.map((adapter) => adapter.name),
+      supportedSources: AddressAggregator.sources(),
+    });
+
+    const allAddresses = await mapAsync(this.adapters, async (adapter) => {
+      const invalidAddresses: string[] = [];
+      const addresses = (await adapter.update(this.logger))
+        .map((address) => {
+          try {
+            return ethersUtils.getAddress(address.toLowerCase());
+          } catch {
+            invalidAddresses.push(address);
+            return INVALID_ADDRESS;
+          }
+        })
+        .filter((address) => address !== INVALID_ADDRESS);
+
+      if (invalidAddresses.length > 0) {
+        this.logger?.warn({
+          at: "AddressAggregator::update()",
+          message: `Read ${invalidAddresses.length} malformed addresses on ${adapter.name}.`,
+          invalidAddresses,
+        });
+      }
+
+      this.logger?.debug({
+        at: "AddressAggregator::update",
+        message: `Loaded ${addresses.length} addresses from ${adapter.name}.`,
+      });
+
+      return addresses;
+    });
+
+    // Dedup the aggregated, normalised, filtered set of addresses.
+    const addresses = new Set(allAddresses.flat());
+
+    this.logger?.debug({
+      at: "AddressAggregator::update",
+      message: `Loaded ${addresses.size} addresses.`,
+      sources: this.adapters.map((adapter) => adapter.name),
+    });
+
+    return addresses;
+  }
+}
+
+async function run(): Promise<number> {
+  const addressList = new AddressAggregator([new adapters.bybit.AddressList(), new adapters.processEnv.AddressList()]);
+
+  const addresses = await addressList.update();
+  console.log(`Retrieved ${addresses.size} addresses: ${JSON.stringify(Array.from(addresses), null, 2)}`);
+
+  return 0;
+}
+
+if (require.main === module) {
+  run()
+    .then((result: number) => {
+      process.exitCode = result;
+    })
+    .catch((error) => {
+      console.error("Process exited with", error);
+      process.exitCode = 127;
+    });
+}

package/src/addressAggregator/types.ts

@@ -0,0 +1,8 @@
+import { Logger } from "../utils";
+
+export interface AddressListAdapter {
+  readonly name: string;
+  update(logger?: Logger): Promise<string[]>;
+}
+
+export const INVALID_ADDRESS = "";

package/src/index.ts

@@ -1,3 +1,4 @@
+export * as addressAggregator from "./addressAggregator";
 export * as lpFeeCalculator from "./lpFeeCalculator";
 export * as pool from "./pool";
 export * as relayFeeCalculator from "./relayFeeCalculator";

package/src/utils/LogUtils.ts

@@ -1,5 +1,6 @@
-import { Logger } from "winston";
+import winston from "winston";
 
+export class Logger extends winston.Logger {}
 export type DefaultLogLevels = "debug" | "info" | "warn" | "error";
 
 type LogParamType = {
@@ -13,7 +14,7 @@ type LogParamType = {
 };
 
 export function formattedLog(
-  logger: Logger | undefined,
+  logger: winston.Logger | undefined,
   { level, message, at: { location, function: fnName }, data }: LogParamType
 ): void {
   if (logger) {