@across-protocol/sdk 4.1.43 → 4.1.44

package/dist/types/addressAggregator/adapters/env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../../src/addressAggregator/adapters/env.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAY,MAAM,QAAQ,CAAC;AAI1C,qBAAa,WAAY,YAAW,kBAAkB;IAGxC,QAAQ,CAAC,MAAM;IAF3B,QAAQ,CAAC,IAAI,iBAAiB;gBAET,MAAM,SAA6B;IAExD,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAkB3C"}
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../../src/addressAggregator/adapters/env.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAI7C,qBAAa,WAAY,SAAQ,eAAe;gBAClC,IAAI,CAAC,EAAE,cAAc;IAIjC,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAkB5B"}

package/dist/types/addressAggregator/adapters/file.d.ts

@@ -1,9 +1,7 @@
-import { AddressListAdapter } from "../types";
-import { Logger } from "./util";
-export declare class AddressList implements AddressListAdapter {
-    readonly path: string;
-    readonly name: string;
-    constructor(path?: string);
-    update(logger?: Logger): Promise<string[]>;
+import { AdapterOptions } from "../types";
+import { AbstractAdapter } from "./abstract";
+export declare class AddressList extends AbstractAdapter {
+    constructor(opts?: AdapterOptions);
+    update(): Promise<string[]>;
 }
 //# sourceMappingURL=file.d.ts.map

package/dist/types/addressAggregator/adapters/file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../../src/addressAggregator/adapters/file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAY,MAAM,QAAQ,CAAC;AAI1C,qBAAa,WAAY,YAAW,kBAAkB;IAGxC,QAAQ,CAAC,IAAI;IAFzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAED,IAAI,SAAqB;IAIxC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAwBjD"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../../src/addressAggregator/adapters/file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAI7C,qBAAa,WAAY,SAAQ,eAAe;gBAClC,IAAI,CAAC,EAAE,cAAc;IAK3B,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAwBlC"}

package/dist/types/addressAggregator/adapters/risklabs.d.ts

@@ -1,11 +1,7 @@
-import { AddressListAdapter } from "../types";
-import { Logger } from "./util";
-export declare class AddressList implements AddressListAdapter {
-    readonly name: string;
-    readonly url: string;
-    readonly timeout = 2000;
-    readonly retries = 1;
-    constructor(name?: string, url?: string);
-    update(logger?: Logger): Promise<string[]>;
+import { AdapterOptions } from "../types";
+import { AbstractAdapter } from "./abstract";
+export declare class AddressList extends AbstractAdapter {
+    constructor(opts?: AdapterOptions);
+    update(): Promise<string[]>;
 }
 //# sourceMappingURL=risklabs.d.ts.map

package/dist/types/addressAggregator/adapters/risklabs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"risklabs.d.ts","sourceRoot":"","sources":["../../../../src/addressAggregator/adapters/risklabs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAY,MAAM,EAAS,MAAM,QAAQ,CAAC;AAMjD,qBAAa,WAAY,YAAW,kBAAkB;IAKlD,QAAQ,CAAC,IAAI;IACb,QAAQ,CAAC,GAAG;IALd,QAAQ,CAAC,OAAO,QAAQ;IACxB,QAAQ,CAAC,OAAO,KAAK;gBAGV,IAAI,SAAe,EACnB,GAAG,SAAc;IAGtB,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CASjD"}
+{"version":3,"file":"risklabs.d.ts","sourceRoot":"","sources":["../../../../src/addressAggregator/adapters/risklabs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAM7C,qBAAa,WAAY,SAAQ,eAAe;gBAClC,IAAI,CAAC,EAAE,cAAc;IAI3B,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAclC"}

package/dist/types/addressAggregator/types.d.ts

@@ -1,7 +1,15 @@
 import { Logger } from "../utils";
+export type AdapterOptions = {
+    name?: string;
+    path?: string;
+    retries?: number;
+    timeout?: number;
+    throwOnError?: boolean;
+    logger?: Logger;
+};
 export interface AddressListAdapter {
     readonly name: string;
-    update(logger?: Logger): Promise<string[]>;
+    update(): Promise<string[]>;
 }
 export declare const INVALID_ADDRESS = "";
 //# sourceMappingURL=types.d.ts.map

package/dist/types/addressAggregator/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/addressAggregator/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CAC5C;AAED,eAAO,MAAM,eAAe,KAAK,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/addressAggregator/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CAC7B;AAED,eAAO,MAAM,eAAe,KAAK,CAAC"}

package/dist/types/constants.d.ts

@@ -27,6 +27,7 @@ export declare const DEFAULT_ARWEAVE_STORAGE_ADDRESS = "Z6hjBM8FHu90lYWB8o5jR1df
 export declare const EMPTY_MESSAGE = "0x";
 export declare const UNDEFINED_MESSAGE_HASH = "";
 export declare const BRIDGED_USDC_SYMBOLS: string[];
+export declare const STABLE_COIN_SYMBOLS: string[];
 export declare const CUSTOM_GAS_TOKENS: {
     [x: number]: string;
 };

package/dist/types/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,4BAA4B,CAAC;AAEpC,eAAO,MAAqB,YAAY,UAAY,UAAU,QAAoB,CAAC;AAGnF,eAAO,MAAM,kBAAkB,kCAAkC,CAAC;AAIlE,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAEhD,eAAO,MAAM,gBAAgB,WAAW,CAAC;AAEzC;;GAEG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAGlC,eAAO,MAAM,2CAA2C,IAAI,CAAC;AAG7D,eAAO,MAAM,oBAAoB,oBAAoB,CAAC;AAOtD,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC,UAA2B,CAAC;AAE1E,eAAO,MAAM,mBAAmB,QAAuB,CAAC;AACxD,eAAO,MAAM,wBAAwB,QAAU,CAAC;AAEhD,eAAO,MAAM,iCAAiC,+CAA+C,CAAC;AAC9F,eAAO,MAAM,sCAAsC,+CAA+C,CAAC;AAEnG,eAAO,MAAM,+BAA+B,gDAAgD,CAAC;AAE7F,eAAO,MAAM,aAAa,OAAO,CAAC;AAClC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,eAAO,MAAM,oBAAoB,UAIhC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;CAM7B,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,4BAA4B,CAAC;AAEpC,eAAO,MAAqB,YAAY,UAAY,UAAU,QAAoB,CAAC;AAGnF,eAAO,MAAM,kBAAkB,kCAAkC,CAAC;AAIlE,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAEhD,eAAO,MAAM,gBAAgB,WAAW,CAAC;AAEzC;;GAEG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAGlC,eAAO,MAAM,2CAA2C,IAAI,CAAC;AAG7D,eAAO,MAAM,oBAAoB,oBAAoB,CAAC;AAOtD,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC,UAA2B,CAAC;AAE1E,eAAO,MAAM,mBAAmB,QAAuB,CAAC;AACxD,eAAO,MAAM,wBAAwB,QAAU,CAAC;AAEhD,eAAO,MAAM,iCAAiC,+CAA+C,CAAC;AAC9F,eAAO,MAAM,sCAAsC,+CAA+C,CAAC;AAEnG,eAAO,MAAM,+BAA+B,gDAAgD,CAAC;AAE7F,eAAO,MAAM,aAAa,OAAO,CAAC;AAClC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,eAAO,MAAM,oBAAoB,UAIhC,CAAC;AAEF,eAAO,MAAM,mBAAmB,UAW/B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;CAM7B,CAAC"}

package/dist/types/utils/TokenUtils.d.ts

@@ -673,6 +673,7 @@ export declare function getCoingeckoTokenIdByAddress(contractAddress: string): s
  */
 export declare function getTokenBalance(address: string, tokenAddress: string, signerOrProvider: SignerOrProvider, blockTag?: BlockTag): Promise<BigNumber>;
 export declare function isBridgedUsdc(tokenSymbol: string): boolean;
+export declare function isStablecoin(tokenSymbol: string): boolean;
 export declare function getTokenInfo(l2TokenAddress: string, chainId: number): L1Token;
 /**
  * Get the USDC symbol for the given token address and chain ID.

package/dist/types/utils/TokenUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAY,SAAS,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAM7C,KAAK,gBAAgB,GAAG,SAAS,CAAC,QAAQ,GAAG,MAAM,CAAC;AAEpD,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAI1G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAY7E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,MAAM,GAAG,SAIX,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,GAAG,OAAO,GAAG,SAAS,CAWrH;AAED,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAM5E;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAc7E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAa/E"}
+{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAY,SAAS,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAM7C,KAAK,gBAAgB,GAAG,SAAS,CAAC,QAAQ,GAAG,MAAM,CAAC;AAEpD,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAI1G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAY7E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,MAAM,GAAG,SAIX,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,GAAG,OAAO,GAAG,SAAS,CAWrH;AAED,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAM5E;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAc7E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAa/E"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.1.43",
+  "version": "4.1.44",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [

package/src/addressAggregator/adapters/abstract.ts

@@ -0,0 +1,74 @@
+import axios from "axios";
+import { AdapterOptions, AddressListAdapter } from "../types";
+import { Logger } from "../../utils";
+
+const { ACROSS_USER_AGENT = "across-protocol" } = process.env;
+
+export abstract class AbstractAdapter implements AddressListAdapter {
+  readonly timeout: number;
+  readonly retries: number;
+  readonly throw: boolean;
+  readonly logger?: Logger;
+
+  constructor(
+    readonly name: string,
+    readonly path: string,
+    opts?: Omit<AdapterOptions, "name" | "path">
+  ) {
+    this.timeout = opts?.timeout ?? 2000;
+    this.retries = opts?.retries ?? 1;
+    this.throw = opts?.throwOnError ?? true;
+    this.logger = opts?.logger;
+  }
+
+  abstract update(logger?: Logger): Promise<string[]>;
+
+  protected sleep(ms: number): Promise<void> {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+
+  protected async 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 this.sleep(Math.pow(1.5, tries) * 1000); // simple backoff
+      }
+    } while (tries <= retries);
+
+    throw new Error(`${name} retrieval failure (${errs.join(", ")})`);
+  }
+
+  protected error(error: unknown): Promise<string[]> {
+    if (this.throw) {
+      throw error;
+    }
+
+    let reason: string;
+    if (error instanceof Error) {
+      reason = error.message;
+    } else {
+      reason = typeof error === "string" ? error : "unknown error";
+    }
+
+    const { name, path, timeout, retries } = this;
+    this.logger?.warn({
+      at: `${name}::update`,
+      message: `Failed to read addresses from ${name}.`,
+      reason,
+      path,
+      retries,
+      timeout,
+    });
+    return Promise.resolve([]);
+  }
+}

package/src/addressAggregator/adapters/bybit.ts

@@ -1,7 +1,8 @@
 import { array, defaulted, string, type } from "superstruct";
-import { AddressListAdapter } from "../types";
-import { logError, Logger, fetch } from "./util";
+import { AdapterOptions } from "../types";
+import { AbstractAdapter } from "./abstract";
 
+const DEFAULT_NAME = "bybit";
 const DEFAULT_URL = "https://hackscan.hackbounty.io/public/hack-address.json";
 
 // This type is a bit message and unweildy. Additional fields representing new chains may be added without notification.
@@ -13,18 +14,16 @@ const bybitResponse = type({
   }),
 });
 
-export class AddressList implements AddressListAdapter {
-  readonly timeout = 2000; // ms
-  readonly retries = 1;
-  readonly name = "bybit";
-
-  constructor(readonly url = DEFAULT_URL) {}
+export class AddressList extends AbstractAdapter {
+  constructor(opts?: AdapterOptions) {
+    super(opts?.name ?? DEFAULT_NAME, opts?.path ?? DEFAULT_URL, opts);
+  }
 
-  async update(logger?: Logger): Promise<string[]> {
-    const response = await fetch(this.name, this.url, this.timeout, this.retries);
+  async update(): Promise<string[]> {
+    const response = await this.fetch(this.name, this.path, this.timeout, this.retries);
     if (!bybitResponse.is(response)) {
       // nb. don't log the response because it might be very large.
-      return logError(this.name, "Failed to validate response", logger);
+      return this.error("Failed to validate response");
     }
 
     return [...response["0221"].eth, ...response["0221"].bsc, ...response["0221"].arbi];

package/src/addressAggregator/adapters/env.ts

@@ -1,16 +1,16 @@
 import { array, defaulted, string } from "superstruct";
-import { AddressListAdapter } from "../types";
-import { Logger, logError } from "./util";
+import { AdapterOptions } from "../types";
+import { AbstractAdapter } from "./abstract";
 
 const envConfig = defaulted(array(string()), []);
 
-export class AddressList implements AddressListAdapter {
-  readonly name = "process.env";
-
-  constructor(readonly envVar = "ACROSS_IGNORED_ADDRESSES") {}
+export class AddressList extends AbstractAdapter {
+  constructor(opts?: AdapterOptions) {
+    super(opts?.name ?? "process.env", opts?.path ?? "ACROSS_IGNORED_ADDRESSES", opts);
+  }
 
-  update(logger?: Logger): Promise<string[]> {
-    const config = process.env[this.envVar];
+  update(): Promise<string[]> {
+    const config = process.env[this.path];
     if (!config) {
       return Promise.resolve([]);
     }
@@ -19,10 +19,10 @@ export class AddressList implements AddressListAdapter {
     try {
       addresses = JSON.parse(config);
       if (!envConfig.is(addresses)) {
-        return logError(this.name, "Address format validation failure.", logger);
+        return this.error("Address format validation failure.");
       }
     } catch (err) {
-      return logError(this.name, err, logger);
+      return this.error(err);
     }
 
     return Promise.resolve(addresses);

package/src/addressAggregator/adapters/file.ts

@@ -1,37 +1,36 @@
 import { readFile } from "node:fs/promises";
 import { array, defaulted, string } from "superstruct";
-import { AddressListAdapter } from "../types";
-import { Logger, logError } from "./util";
+import { AdapterOptions } from "../types";
+import { AbstractAdapter } from "./abstract";
 
 const fileConfig = defaulted(array(string()), []);
 
-export class AddressList implements AddressListAdapter {
-  readonly name: string;
-
-  constructor(readonly path = "./addresses.json") {
-    this.name = `fs:${path}`;
+export class AddressList extends AbstractAdapter {
+  constructor(opts?: AdapterOptions) {
+    const { path = "addresses.json" } = opts ?? {};
+    super(opts?.name ?? `fs:${path}`, path, opts);
   }
 
-  async update(logger?: Logger): Promise<string[]> {
+  async update(): Promise<string[]> {
     let data: string;
     try {
       data = await readFile(this.path, { encoding: "utf8" });
     } catch (err) {
-      return logError(this.name, err, logger);
+      return this.error(err);
     }
 
     if (!data) {
-      return logError(this.name, `No addresses found in "${this.path}"`, logger);
+      return this.error("No addresses found");
     }
 
     let addresses: unknown;
     try {
       addresses = JSON.parse(data);
       if (!fileConfig.is(addresses)) {
-        return logError(this.name, "Address format validation failure.", logger);
+        return this.error("Address format validation failure.");
       }
     } catch (err) {
-      return logError(this.name, err, logger);
+      return this.error(err);
     }
 
     return Promise.resolve(addresses);

package/src/addressAggregator/adapters/risklabs.ts

@@ -1,25 +1,26 @@
 import { array, string } from "superstruct";
-import { AddressListAdapter } from "../types";
-import { logError, Logger, fetch } from "./util";
+import { AdapterOptions } from "../types";
+import { AbstractAdapter } from "./abstract";
 
 const RESPONSE_TYPE = array(string());
 const DEFAULT_NAME = "Risk Labs";
 const DEFAULT_URL = "https://blacklist.risklabs.foundation/api/blacklist";
 
-export class AddressList implements AddressListAdapter {
-  readonly timeout = 2000; // ms
-  readonly retries = 1;
-
-  constructor(
-    readonly name = DEFAULT_NAME,
-    readonly url = DEFAULT_URL
-  ) {}
+export class AddressList extends AbstractAdapter {
+  constructor(opts?: AdapterOptions) {
+    super(opts?.name ?? DEFAULT_NAME, opts?.path ?? DEFAULT_URL, opts);
+  }
 
-  async update(logger?: Logger): Promise<string[]> {
-    const response = await fetch(this.name, this.url, this.timeout, this.retries);
+  async update(): Promise<string[]> {
+    let response: unknown;
+    try {
+      response = await this.fetch(this.name, this.path, this.timeout, this.retries);
+    } catch (err) {
+      return this.error(err);
+    }
 
     if (!RESPONSE_TYPE.is(response)) {
-      return logError(this.name, "Failed to validate response", logger);
+      return this.error("Failed to validate response");
     }
 
     return response;

package/src/addressAggregator/index.ts

@@ -25,7 +25,7 @@ export class AddressAggregator {
 
     const allAddresses = await mapAsync(this.adapters, async (adapter) => {
       const invalidAddresses: string[] = [];
-      const addresses = (await adapter.update(this.logger))
+      const addresses = (await adapter.update())
         .map((address) => {
           try {
             return ethersUtils.getAddress(address.toLowerCase());
@@ -66,7 +66,7 @@ export class AddressAggregator {
 }
 
 async function run(): Promise<number> {
-  const addressList = new AddressAggregator([new adapters.risklabs.AddressList()]);
+  const addressList = new AddressAggregator([new adapters.risklabs.AddressList({ throwOnError: true })]);
 
   const addresses = await addressList.update();
   console.log(`Retrieved ${addresses.size} addresses: ${JSON.stringify(Array.from(addresses), null, 2)}`);

package/src/addressAggregator/types.ts

@@ -1,8 +1,17 @@
 import { Logger } from "../utils";
 
+export type AdapterOptions = {
+  name?: string;
+  path?: string;
+  retries?: number;
+  timeout?: number;
+  throwOnError?: boolean;
+  logger?: Logger;
+};
+
 export interface AddressListAdapter {
   readonly name: string;
-  update(logger?: Logger): Promise<string[]>;
+  update(): Promise<string[]>;
 }
 
 export const INVALID_ADDRESS = "";

package/src/constants.ts

@@ -66,6 +66,19 @@ export const BRIDGED_USDC_SYMBOLS = [
   TOKEN_SYMBOLS_MAP.USDzC.symbol,
 ];
 
+export const STABLE_COIN_SYMBOLS = [
+  ...BRIDGED_USDC_SYMBOLS,
+  TOKEN_SYMBOLS_MAP.USDB.symbol,
+  TOKEN_SYMBOLS_MAP.USDC.symbol,
+  TOKEN_SYMBOLS_MAP.USDT.symbol,
+  TOKEN_SYMBOLS_MAP.DAI.symbol,
+  TOKEN_SYMBOLS_MAP["TATARA-USDC"].symbol,
+  TOKEN_SYMBOLS_MAP["TATARA-USDT"].symbol,
+  TOKEN_SYMBOLS_MAP["TATARA-USDS"].symbol,
+  TOKEN_SYMBOLS_MAP.GHO.symbol,
+  TOKEN_SYMBOLS_MAP.WGHO.symbol,
+];
+
 export const CUSTOM_GAS_TOKENS = {
   [CHAIN_IDs.POLYGON]: "MATIC",
   [CHAIN_IDs.POLYGON_AMOY]: "MATIC",

package/src/utils/TokenUtils.ts

@@ -109,6 +109,12 @@ export function isBridgedUsdc(tokenSymbol: string): boolean {
   );
 }
 
+export function isStablecoin(tokenSymbol: string): boolean {
+  return constants.STABLE_COIN_SYMBOLS.some(
+    (stablecoinSymbol) => stablecoinSymbol.toLowerCase() === tokenSymbol.toLowerCase()
+  );
+}
+
 export function getTokenInfo(l2TokenAddress: string, chainId: number): L1Token {
   // @dev This might give false positives if tokens on different networks have the same address. I'm not sure how
   // to get around this...

package/dist/cjs/addressAggregator/adapters/util.d.ts

@@ -1,4 +0,0 @@
-import { Logger } from "../../utils";
-export { Logger } from "../../utils";
-export declare function logError(name: string, error: unknown, logger?: Logger): Promise<string[]>;
-export declare function fetch(name: string, url: string, timeout?: number, retries?: number): Promise<unknown>;

package/dist/cjs/addressAggregator/adapters/util.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetch = exports.logError = exports.Logger = void 0;
-var tslib_1 = require("tslib");
-var axios_1 = tslib_1.__importDefault(require("axios"));
-var utils_1 = require("../../utils");
-Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return utils_1.Logger; } });
-var _a = process.env.ACROSS_USER_AGENT, ACROSS_USER_AGENT = _a === void 0 ? "across-protocol" : _a;
-function sleep(ms) {
-    return new Promise(function (r) { return setTimeout(r, ms); });
-}
-function logError(name, error, logger) {
-    var reason;
-    if (error instanceof Error) {
-        reason = error.message;
-    }
-    else {
-        reason = typeof error === "string" ? error : "unknown error";
-    }
-    logger === null || logger === void 0 ? void 0 : logger.warn({
-        at: "".concat(name, "::update"),
-        message: "Failed to read addresses from ".concat(name, "."),
-        reason: reason,
-    });
-    return Promise.resolve([]);
-}
-exports.logError = logError;
-function fetch(name, url, timeout, retries) {
-    if (timeout === void 0) { timeout = 2000; }
-    if (retries === void 0) { retries = 1; }
-    return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var args, errs, tries, err_1, errMsg;
-        return tslib_1.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    args = {
-                        headers: { "User-Agent": ACROSS_USER_AGENT },
-                        timeout: timeout,
-                    };
-                    errs = [];
-                    tries = 0;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 6]);
-                    return [4, (0, axios_1.default)(url, args)];
-                case 2: return [2, (_a.sent()).data];
-                case 3:
-                    err_1 = _a.sent();
-                    errMsg = axios_1.default.isAxiosError(err_1) || err_1 instanceof Error ? err_1.message : "unknown error";
-                    errs.push(errMsg);
-                    if (!(++tries <= retries)) return [3, 5];
-                    return [4, sleep(Math.pow(1.5, tries) * 1000)];
-                case 4:
-                    _a.sent();
-                    _a.label = 5;
-                case 5: return [3, 6];
-                case 6:
-                    if (tries <= retries) return [3, 1];
-                    _a.label = 7;
-                case 7: throw new Error("".concat(name, " retrieval failure (").concat(errs.join(", "), ")"));
-            }
-        });
-    });
-}
-exports.fetch = fetch;
-//# sourceMappingURL=util.js.map

package/dist/cjs/addressAggregator/adapters/util.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../src/addressAggregator/adapters/util.ts"],"names":[],"mappings":";;;;AAAA,wDAA0B;AAG1B,qCAAqC;AAA5B,+FAAA,MAAM,OAAA;AAEP,IAAA,KAA0C,OAAO,CAAC,GAAG,kBAAhB,EAArC,iBAAiB,mBAAG,iBAAiB,KAAA,CAAiB;AAE9D,SAAS,KAAK,CAAC,EAAU;IACvB,OAAO,IAAI,OAAO,CAAC,UAAC,CAAC,IAAK,OAAA,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC,EAAjB,CAAiB,CAAC,CAAC;AAC/C,CAAC;AAED,SAAgB,QAAQ,CAAC,IAAY,EAAE,KAAc,EAAE,MAAe;IACpE,IAAI,MAAc,CAAC;IACnB,IAAI,KAAK,YAAY,KAAK,EAAE;QAC1B,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC;KACxB;SAAM;QACL,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,eAAe,CAAC;KAC9D;IAED,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,IAAI,CAAC;QACX,EAAE,EAAE,UAAG,IAAI,aAAU;QACrB,OAAO,EAAE,wCAAiC,IAAI,MAAG;QACjD,MAAM,QAAA;KACP,CAAC,CAAC;IACH,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;AAC7B,CAAC;AAdD,4BAcC;AAED,SAAsB,KAAK,CAAC,IAAY,EAAE,GAAW,EAAE,OAAc,EAAE,OAAW;IAA3B,wBAAA,EAAA,cAAc;IAAE,wBAAA,EAAA,WAAW;;;;;;oBAC1E,IAAI,GAAG;wBACX,OAAO,EAAE,EAAE,YAAY,EAAE,iBAAiB,EAAE;wBAC5C,OAAO,SAAA;qBACR,CAAC;oBAEI,IAAI,GAAa,EAAE,CAAC;oBACtB,KAAK,GAAG,CAAC,CAAC;;;;oBAGF,WAAM,IAAA,eAAK,EAAC,GAAG,EAAE,IAAI,CAAC,EAAA;wBAA9B,WAAO,CAAC,SAAsB,CAAC,CAAC,IAAI,EAAC;;;oBAE/B,MAAM,GAAG,eAAK,CAAC,YAAY,CAAC,KAAG,CAAC,IAAI,KAAG,YAAY,KAAK,CAAC,CAAC,CAAC,KAAG,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC;oBAC/F,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;yBACd,CAAA,EAAE,KAAK,IAAI,OAAO,CAAA,EAAlB,cAAkB;oBAAE,WAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,EAAA;;oBAAxC,SAAwC,CAAC;;;;wBAE5D,KAAK,IAAI,OAAO;;wBAEzB,MAAM,IAAI,KAAK,CAAC,UAAG,IAAI,iCAAuB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAG,CAAC,CAAC;;;;CACnE;AAnBD,sBAmBC"}

package/dist/esm/addressAggregator/adapters/util.d.ts

@@ -1,4 +0,0 @@
-import { Logger } from "../../utils";
-export { Logger } from "../../utils";
-export declare function logError(name: string, error: unknown, logger?: Logger): Promise<string[]>;
-export declare function fetch(name: string, url: string, timeout?: number, retries?: number): Promise<unknown>;

package/dist/esm/addressAggregator/adapters/util.js

@@ -1,60 +0,0 @@
-import { __awaiter, __generator } from "tslib";
-import axios from "axios";
-export { Logger } from "../../utils";
-var _a = process.env.ACROSS_USER_AGENT, ACROSS_USER_AGENT = _a === void 0 ? "across-protocol" : _a;
-function sleep(ms) {
-    return new Promise(function (r) { return setTimeout(r, ms); });
-}
-export function logError(name, error, logger) {
-    var reason;
-    if (error instanceof Error) {
-        reason = error.message;
-    }
-    else {
-        reason = typeof error === "string" ? error : "unknown error";
-    }
-    logger === null || logger === void 0 ? void 0 : logger.warn({
-        at: "".concat(name, "::update"),
-        message: "Failed to read addresses from ".concat(name, "."),
-        reason: reason,
-    });
-    return Promise.resolve([]);
-}
-export function fetch(name, url, timeout, retries) {
-    if (timeout === void 0) { timeout = 2000; }
-    if (retries === void 0) { retries = 1; }
-    return __awaiter(this, void 0, void 0, function () {
-        var args, errs, tries, err_1, errMsg;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    args = {
-                        headers: { "User-Agent": ACROSS_USER_AGENT },
-                        timeout: timeout,
-                    };
-                    errs = [];
-                    tries = 0;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 6]);
-                    return [4 /*yield*/, axios(url, args)];
-                case 2: return [2 /*return*/, (_a.sent()).data];
-                case 3:
-                    err_1 = _a.sent();
-                    errMsg = axios.isAxiosError(err_1) || err_1 instanceof Error ? err_1.message : "unknown error";
-                    errs.push(errMsg);
-                    if (!(++tries <= retries)) return [3 /*break*/, 5];
-                    return [4 /*yield*/, sleep(Math.pow(1.5, tries) * 1000)];
-                case 4:
-                    _a.sent(); // simple backoff
-                    _a.label = 5;
-                case 5: return [3 /*break*/, 6];
-                case 6:
-                    if (tries <= retries) return [3 /*break*/, 1];
-                    _a.label = 7;
-                case 7: throw new Error("".concat(name, " retrieval failure (").concat(errs.join(", "), ")"));
-            }
-        });
-    });
-}
-//# sourceMappingURL=util.js.map

package/dist/esm/addressAggregator/adapters/util.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../src/addressAggregator/adapters/util.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE7B,IAAA,KAA0C,OAAO,CAAC,GAAG,kBAAhB,EAArC,iBAAiB,mBAAG,iBAAiB,KAAA,CAAiB;AAE9D,SAAS,KAAK,CAAC,EAAU;IACvB,OAAO,IAAI,OAAO,CAAC,UAAC,CAAC,IAAK,OAAA,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC,EAAjB,CAAiB,CAAC,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,IAAY,EAAE,KAAc,EAAE,MAAe;IACpE,IAAI,MAAc,CAAC;IACnB,IAAI,KAAK,YAAY,KAAK,EAAE;QAC1B,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC;KACxB;SAAM;QACL,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,eAAe,CAAC;KAC9D;IAED,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,IAAI,CAAC;QACX,EAAE,EAAE,UAAG,IAAI,aAAU;QACrB,OAAO,EAAE,wCAAiC,IAAI,MAAG;QACjD,MAAM,QAAA;KACP,CAAC,CAAC;IACH,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;AAC7B,CAAC;AAED,MAAM,UAAgB,KAAK,CAAC,IAAY,EAAE,GAAW,EAAE,OAAc,EAAE,OAAW;IAA3B,wBAAA,EAAA,cAAc;IAAE,wBAAA,EAAA,WAAW;;;;;;oBAC1E,IAAI,GAAG;wBACX,OAAO,EAAE,EAAE,YAAY,EAAE,iBAAiB,EAAE;wBAC5C,OAAO,SAAA;qBACR,CAAC;oBAEI,IAAI,GAAa,EAAE,CAAC;oBACtB,KAAK,GAAG,CAAC,CAAC;;;;oBAGF,qBAAM,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,EAAA;wBAA9B,sBAAO,CAAC,SAAsB,CAAC,CAAC,IAAI,EAAC;;;oBAE/B,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC,KAAG,CAAC,IAAI,KAAG,YAAY,KAAK,CAAC,CAAC,CAAC,KAAG,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC;oBAC/F,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;yBACd,CAAA,EAAE,KAAK,IAAI,OAAO,CAAA,EAAlB,wBAAkB;oBAAE,qBAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,EAAA;;oBAAxC,SAAwC,CAAC,CAAC,iBAAiB;;;;wBAE9E,KAAK,IAAI,OAAO;;wBAEzB,MAAM,IAAI,KAAK,CAAC,UAAG,IAAI,iCAAuB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAG,CAAC,CAAC;;;;CACnE"}

package/dist/types/addressAggregator/adapters/util.d.ts

@@ -1,5 +0,0 @@
-import { Logger } from "../../utils";
-export { Logger } from "../../utils";
-export declare function logError(name: string, error: unknown, logger?: Logger): Promise<string[]>;
-export declare function fetch(name: string, url: string, timeout?: number, retries?: number): Promise<unknown>;
-//# sourceMappingURL=util.d.ts.map

package/dist/types/addressAggregator/adapters/util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../src/addressAggregator/adapters/util.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAQrC,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAczF;AAED,wBAAsB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,SAAO,EAAE,OAAO,SAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBpG"}