@gearbox-protocol/sdk 13.1.0-next.2 → 13.1.0

package/dist/cjs/dev/AccountOpener.js

@@ -52,7 +52,6 @@ class AccountOpener extends import_sdk.SDKConstruct {
   #minDebtMultiplier;
   #allowMint;
   #leverageDelta;
-  #poolService;
   constructor(service, options_ = {}) {
     super(service.sdk);
     const {
@@ -78,7 +77,6 @@ class AccountOpener extends import_sdk.SDKConstruct {
     this.#poolDepositMultiplier = BigInt(poolDepositMultiplier);
     this.#minDebtMultiplier = BigInt(minDebtMultiplier);
     this.#leverageDelta = BigInt(leverageDelta);
-    this.#poolService = new import_sdk.PoolService(service.sdk);
     this.#logger?.info(
       {
         borrower: (0, import_accounts.privateKeyToAccount)(this.borrowerKey).address,
@@ -116,10 +114,6 @@ class AccountOpener extends import_sdk.SDKConstruct {
       },
       "opening credit accounts"
     );
-    await Promise.all([
-      this.sdk.tokensMeta.loadTokenData(),
-      this.sdk.marketRegister.loadZappers()
-    ]);
     let deposits = [];
     if (depositIntoPools) {
       try {
@@ -471,34 +465,9 @@ class AccountOpener extends import_sdk.SDKConstruct {
       this.#logger?.debug(
         `depositor balance in underlying: ${this.sdk.tokensMeta.formatBN(pool.underlying, allowance, { symbol: true })}`
       );
-      const tokensOut = this.#poolService.getDepositTokensOut(
-        address,
-        underlying
-      );
-      this.#logger?.debug(
-        { tokensOut: tokensOut.map((t) => this.labelAddress(t)) },
-        "deposit tokens out"
-      );
-      if (tokensOut.length === 0) {
-        throw new Error(`no tokens out found for pool ${poolName}`);
-      }
-      const tokenOut = tokensOut[0];
-      const metadata = this.#poolService.getDepositMetadata(
-        address,
-        underlying,
-        tokenOut
-      );
-      this.logger?.debug(
-        {
-          underlying: this.labelAddress(underlying),
-          tokenOut: this.labelAddress(tokenOut),
-          ...metadata
-        },
-        "pool deposit metadata"
-      );
       txHash = await this.#anvil.writeContract({
         account: depositor,
-        address: metadata.approveTarget,
+        address: underlying,
         abi: import_iERC20.ierc20Abi,
         functionName: "approve",
         args: [address, allowance],
@@ -515,21 +484,12 @@ class AccountOpener extends import_sdk.SDKConstruct {
       this.#logger?.debug(
         `depositor approved underlying for pool ${poolName}: ${txHash}`
       );
-      const depositCall = this.#poolService.addLiquidity({
-        collateral: { token: underlying, balance: amount },
-        pool: address,
-        wallet: depositor.address,
-        meta: metadata
-      });
-      if (!depositCall) {
-        throw new Error(`no deposit call could be created for ${poolName}`);
-      }
       txHash = await this.#anvil.writeContract({
         account: depositor,
-        address: depositCall.target,
-        abi: depositCall.abi,
-        functionName: depositCall.functionName,
-        args: depositCall.args,
+        address,
+        abi: import_generated.iPoolV310Abi,
+        functionName: "deposit",
+        args: [amount, depositor.address],
         chain: this.#anvil.chain
       });
       receipt = await this.#anvil.waitForTransactionReceipt({ hash: txHash });

package/dist/cjs/dev/index.js

@@ -23,12 +23,16 @@ __reExport(dev_exports, require("./create2.js"), module.exports);
 __reExport(dev_exports, require("./createAnvilClient.js"), module.exports);
 __reExport(dev_exports, require("./detectChain.js"), module.exports);
 __reExport(dev_exports, require("./EthCallSpy.js"), module.exports);
+__reExport(dev_exports, require("./isOutOfSyncError.js"), module.exports);
+__reExport(dev_exports, require("./isRateLimitError.js"), module.exports);
+__reExport(dev_exports, require("./isTransientError.js"), module.exports);
 __reExport(dev_exports, require("./ltUtils.js"), module.exports);
 __reExport(dev_exports, require("./migrateFaucet.js"), module.exports);
 __reExport(dev_exports, require("./mint/index.js"), module.exports);
 __reExport(dev_exports, require("./providers.js"), module.exports);
 __reExport(dev_exports, require("./RevolverTransport.js"), module.exports);
 __reExport(dev_exports, require("./replaceStorage.js"), module.exports);
+__reExport(dev_exports, require("./resilientTransport.js"), module.exports);
 __reExport(dev_exports, require("./transports.js"), module.exports);
 __reExport(dev_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
@@ -41,12 +45,16 @@ __reExport(dev_exports, require("./types.js"), module.exports);
   ...require("./createAnvilClient.js"),
   ...require("./detectChain.js"),
   ...require("./EthCallSpy.js"),
+  ...require("./isOutOfSyncError.js"),
+  ...require("./isRateLimitError.js"),
+  ...require("./isTransientError.js"),
   ...require("./ltUtils.js"),
   ...require("./migrateFaucet.js"),
   ...require("./mint/index.js"),
   ...require("./providers.js"),
   ...require("./RevolverTransport.js"),
   ...require("./replaceStorage.js"),
+  ...require("./resilientTransport.js"),
   ...require("./transports.js"),
   ...require("./types.js")
 });

package/dist/cjs/dev/isOutOfSyncError.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isOutOfSyncError_exports = {};
+__export(isOutOfSyncError_exports, {
+  isOutOfSyncError: () => isOutOfSyncError
+});
+module.exports = __toCommonJS(isOutOfSyncError_exports);
+var import_viem = require("viem");
+const OUT_OF_SYNC_PATTERNS = [
+  // Alchemy (code 3), DRPC (code 26), Thirdweb (code 26) on Mainnet/Plasma/Monad
+  /unknown block/i,
+  // Ankr (code -32000) on Mainnet
+  /header not found/i,
+  // Alchemy, Ankr, Thirdweb, direct Monad RPCs (code -32602)
+  /block requested not found/i,
+  // Ankr, Thirdweb, direct Somnia RPCs (code -1)
+  /unable to load historical state/i,
+  // Ankr, Thirdweb, direct Etherlink RPCs (code -32603)
+  /no state available for block/i,
+  // Generic "block not found" (code -32001) from various providers
+  /block\b.*\bnot found/i,
+  // Optimism proxyd (code -32019) for future/non-existent blocks
+  /block is out of range/i,
+  // EIP-1474 standard (code -32001) when block/state is not available
+  /resource not found/i
+];
+function isOutOfSyncError(e) {
+  if (e instanceof import_viem.BaseError) {
+    const match = e.walk((err) => {
+      const msg = err.details ?? err.message ?? "";
+      return OUT_OF_SYNC_PATTERNS.some((re) => re.test(msg));
+    });
+    return match !== null;
+  }
+  return OUT_OF_SYNC_PATTERNS.some((re) => re.test(e.message));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isOutOfSyncError
+});

package/dist/cjs/dev/isRateLimitError.js

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isRateLimitError_exports = {};
+__export(isRateLimitError_exports, {
+  isRateLimitError: () => isRateLimitError
+});
+module.exports = __toCommonJS(isRateLimitError_exports);
+var import_viem = require("viem");
+const RATE_LIMIT_PATTERNS = [
+  // Thirdweb (status 429): "You've been rate limited, please upgrade your plan."
+  // Monad direct/Cloudflare (status 429): "You are being rate limited"
+  /rate limit/i,
+  // DRPC (code 15, status 429): "Too many request, try again later"
+  // Ankr (status 429): HTML "<title>429 Too Many Requests</title>"
+  /too many request/i,
+  // Alchemy (code 429, status 429): "Your app has exceeded its compute units per second capacity"
+  /exceeded its compute units/i,
+  // Providers embedding retry hints: "retry after 5 seconds", "retry in 10s"
+  /retry.{0,10}(in|after)\s+\d/i
+];
+function extractRetryAfter(headers) {
+  if (!headers) {
+    return void 0;
+  }
+  const val = headers.get("retry-after");
+  if (!val) {
+    return void 0;
+  }
+  const seconds = Number(val);
+  if (!Number.isNaN(seconds)) {
+    return seconds * 1e3;
+  }
+  const date = Date.parse(val);
+  if (!Number.isNaN(date)) {
+    return Math.max(0, date - Date.now());
+  }
+  return void 0;
+}
+function isRateLimitError(e) {
+  if (e instanceof import_viem.BaseError) {
+    let retryAfterMs;
+    const httpMatch = e.walk((err) => {
+      if (err instanceof import_viem.HttpRequestError && err.status === 429) {
+        retryAfterMs = extractRetryAfter(err.headers);
+        return true;
+      }
+      return false;
+    });
+    if (httpMatch !== null) return [true, retryAfterMs];
+    const msgMatch = e.walk((err) => {
+      const msg = err.details ?? err.message ?? "";
+      return RATE_LIMIT_PATTERNS.some((re) => re.test(msg));
+    });
+    if (msgMatch !== null) return [true, void 0];
+  }
+  if (RATE_LIMIT_PATTERNS.some((re) => re.test(e.message))) {
+    return [true, void 0];
+  }
+  return [false, void 0];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isRateLimitError
+});

package/dist/cjs/dev/isTransientError.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isTransientError_exports = {};
+__export(isTransientError_exports, {
+  isTransientError: () => isTransientError
+});
+module.exports = __toCommonJS(isTransientError_exports);
+var import_viem = require("viem");
+const TRANSIENT_HTTP_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
+const TRANSIENT_PATTERNS = [
+  // viem TimeoutError: RPC endpoint didn't respond within configured timeout
+  // (default 10s). details = "The request timed out."
+  /timed?\s*out/i,
+  // Node.js ECONNRESET: TCP connection forcibly closed by the server mid-request,
+  // typically during server restarts or under heavy load.
+  // Wrapped by viem in HttpRequestError with cause TypeError("fetch failed")
+  /econnreset/i,
+  // Node.js "socket hang up": server closed the TCP connection before sending
+  // a complete response, similar to ECONNRESET but at HTTP level
+  /socket hang up/i,
+  // Browser/Node.js fetch failures: DNS resolution failure, connection refused,
+  // unreachable host, or CORS errors. Wrapped in HttpRequestError by viem.
+  /network error|failed to fetch|fetch failed/i,
+  // HTTP 503 text in response body when status check alone doesn't catch it
+  // (e.g., HTML error page from a CDN/proxy during maintenance or overload)
+  /service unavailable/i,
+  // HTTP 502 text in response body from load balancer/reverse proxy when the
+  // backend RPC node is unreachable or returned an invalid response
+  /bad gateway/i,
+  // HTTP 504 text in response body from gateway/proxy when the upstream RPC
+  // node didn't respond in time
+  /gateway time/i,
+  // Malformed JSON-RPC response: server returned 200 with empty/null body or
+  // non-JSON content despite application/json content-type, causing viem's
+  // response parser to fail with a destructuring TypeError
+  /cannot destructure/i,
+  // viem UnknownRpcError: provider returned a JSON-RPC error with an
+  // unrecognized error code that viem can't categorize.
+  // shortMessage = "An unknown RPC error occurred."
+  /unknown rpc error/i,
+  // EIP-1474 ResourceUnavailableRpcError (code -32002): node is syncing or the
+  // requested resource is temporarily unavailable.
+  // Matches both the RPC message and viem's shortMessage "Requested resource not available."
+  /resource unavailable|requested resource not available/i
+];
+function isTransientError(e) {
+  if (e instanceof import_viem.BaseError) {
+    if (e instanceof import_viem.TimeoutError) return true;
+    const httpMatch = e.walk((err) => {
+      if (err instanceof import_viem.HttpRequestError && err.status !== void 0 && TRANSIENT_HTTP_STATUSES.has(err.status)) {
+        return true;
+      }
+      return false;
+    });
+    if (httpMatch !== null) return true;
+    const msgMatch = e.walk((err) => {
+      const msg = err.details ?? err.message ?? "";
+      return TRANSIENT_PATTERNS.some((re) => re.test(msg));
+    });
+    return msgMatch !== null;
+  }
+  return TRANSIENT_PATTERNS.some((re) => re.test(e.message));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isTransientError
+});

package/dist/cjs/dev/providers.js

@@ -77,7 +77,7 @@ const DRPC_NETS = {
   MegaETH: "megaeth",
   Etherlink: null,
   Plasma: "plasma",
-  Somnia: "somnia"
+  Somnia: null
 };
 const ALCHEMY_DOMAINS = {
   Mainnet: "eth-mainnet",

package/dist/cjs/dev/resilientTransport.js

@@ -0,0 +1,104 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resilientTransport_exports = {};
+__export(resilientTransport_exports, {
+  resilientTransport: () => resilientTransport,
+  resilientTransportOptionsSchema: () => resilientTransportOptionsSchema
+});
+module.exports = __toCommonJS(resilientTransport_exports);
+var import_viem = require("viem");
+var import_v4 = require("zod/v4");
+var import_isOutOfSyncError = require("./isOutOfSyncError.js");
+var import_isRateLimitError = require("./isRateLimitError.js");
+var import_isTransientError = require("./isTransientError.js");
+const resilientTransportOptionsSchema = import_v4.z.object({
+  /**
+   * Max retry attempts.
+   * @default 3
+   **/
+  retryCount: import_v4.z.number().int().min(0).default(3),
+  /**
+   * Base delay (ms) for exponential backoff.
+   * @default 300
+   **/
+  delay: import_v4.z.number().min(0).default(300),
+  /**
+   * Upper bound (ms) for backoff delay.
+   * @default 5_000
+   **/
+  maxDelay: import_v4.z.number().min(0).default(5e3),
+  /**
+   * Max random jitter (ms) added to each delay.
+   * @default 100
+   **/
+  jitter: import_v4.z.number().min(0).default(100),
+  /**
+   * Retry on rate-limit (HTTP 429) errors.
+   * @default true
+   **/
+  handleRateLimit: import_v4.z.boolean().default(true),
+  /**
+   * Retry on transient network/infrastructure errors.
+   * @default true
+   **/
+  handleTransient: import_v4.z.boolean().default(true),
+  /**
+   * Retry on out-of-sync / block-not-found errors.
+   * @default true
+   **/
+  handleOutOfSync: import_v4.z.boolean().default(true)
+});
+function resilientTransport(underlyingTransport, options) {
+  const opts = resilientTransportOptionsSchema.parse(options ?? {});
+  return (transportOpts) => {
+    const base = underlyingTransport(transportOpts);
+    const rpcRequest = base.request;
+    const request = async (args) => (0, import_viem.withRetry)(() => rpcRequest(args), {
+      retryCount: opts.retryCount,
+      delay({ count, error }) {
+        if (opts.handleRateLimit) {
+          const [isRate, retryAfterMs] = (0, import_isRateLimitError.isRateLimitError)(error);
+          if (isRate && retryAfterMs !== void 0) {
+            return retryAfterMs + Math.floor(Math.random() * opts.jitter);
+          }
+        }
+        const exp = Math.min(opts.maxDelay, opts.delay * 2 ** count);
+        return exp + Math.floor(Math.random() * opts.jitter);
+      },
+      shouldRetry({ error }) {
+        if (opts.handleRateLimit && (0, import_isRateLimitError.isRateLimitError)(error)[0]) {
+          return true;
+        }
+        if (opts.handleTransient && (0, import_isTransientError.isTransientError)(error)) {
+          return true;
+        }
+        if (opts.handleOutOfSync && (0, import_isOutOfSyncError.isOutOfSyncError)(error)) {
+          return true;
+        }
+        return false;
+      }
+    });
+    return { ...base, request };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resilientTransport,
+  resilientTransportOptionsSchema
+});

package/dist/cjs/plugins/zappers/ZappersPlugin.js

@@ -0,0 +1,144 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ZappersPlugin_exports = {};
+__export(ZappersPlugin_exports, {
+  ZappersPlugin: () => ZappersPlugin
+});
+module.exports = __toCommonJS(ZappersPlugin_exports);
+var import_peripheryCompressor = require("../../abi/compressors/peripheryCompressor.js");
+var import_sdk = require("../../sdk/index.js");
+class ZappersPlugin extends import_sdk.BasePlugin {
+  #zappers;
+  #extraZappers;
+  constructor(extraZappers = [], loadOnAttach = false) {
+    super(loadOnAttach);
+    this.#extraZappers = this.#addExtraZappers(extraZappers);
+  }
+  async load(force) {
+    if (!force && this.loaded) {
+      return this.state;
+    }
+    const [pcAddr] = this.sdk.addressProvider.mustGetLatest(
+      import_sdk.AP_PERIPHERY_COMPRESSOR,
+      import_sdk.VERSION_RANGE_310
+    );
+    this.sdk.logger?.debug(
+      `loading zappers with periphery compressor ${pcAddr}`
+    );
+    const markets = this.sdk.marketRegister.markets;
+    const resp = await this.client.multicall({
+      contracts: markets.map(
+        (m) => ({
+          abi: import_peripheryCompressor.peripheryCompressorAbi,
+          address: pcAddr,
+          functionName: "getZappers",
+          args: [m.configurator.address, m.pool.pool.address]
+        })
+      ),
+      allowFailure: true,
+      batchSize: 0,
+      blockNumber: this.sdk.currentBlock
+    });
+    this.#zappers = new import_sdk.AddressMap(void 0, "zappers");
+    for (let i = 0; i < resp.length; i++) {
+      const { status, result, error } = resp[i];
+      const marketConfigurator = markets[i].configurator.address;
+      const pool = markets[i].pool.pool.address;
+      if (status === "success") {
+        this.#zappers.upsert(
+          pool,
+          result.map((z) => ({ ...z, pool }))
+        );
+      } else {
+        this.sdk.logger?.error(
+          `failed to load zapper for market configurator ${this.labelAddress(
+            marketConfigurator
+          )} and pool ${this.labelAddress(pool)}: ${error}`
+        );
+      }
+    }
+    this.#loadZapperTokens();
+    return this.state;
+  }
+  #addExtraZappers(extraZappers) {
+    const zappers = new import_sdk.AddressMap();
+    for (const z of extraZappers) {
+      const existing = zappers?.get(z.pool);
+      if (existing) {
+        const hasZapper = existing.some(
+          (zz) => (0, import_sdk.hexEq)(zz.baseParams.addr, z.baseParams.addr)
+        );
+        if (!hasZapper) {
+          existing.push(z);
+        }
+      } else {
+        zappers?.upsert(z.pool, [z]);
+      }
+    }
+    return zappers;
+  }
+  get extraZappers() {
+    if (!this.#extraZappers) {
+      console.error("extra zappers not attached");
+      return new import_sdk.AddressMap();
+    }
+    return this.#extraZappers;
+  }
+  get zappers() {
+    if (!this.#zappers) {
+      throw new Error("zappers plugin not attached");
+    }
+    return this.#zappers;
+  }
+  get loaded() {
+    return !!this.#zappers;
+  }
+  stateHuman(_) {
+    return this.zappers.values().flatMap(
+      (l) => l.flatMap((z) => ({
+        address: z.baseParams.addr,
+        contractType: z.baseParams.contractType,
+        version: Number(z.baseParams.version),
+        tokenIn: this.labelAddress(z.tokenIn.addr),
+        tokenOut: this.labelAddress(z.tokenOut.addr)
+      }))
+    );
+  }
+  get state() {
+    return {
+      zappers: this.zappers.asRecord()
+    };
+  }
+  hydrate(state) {
+    this.#zappers = new import_sdk.AddressMap(Object.entries(state.zappers), "zappers");
+    this.#loadZapperTokens();
+  }
+  #loadZapperTokens() {
+    const zappersTokens = this.zappers.values().flatMap((l) => l.flatMap((z) => [z.tokenIn, z.tokenOut]));
+    const extraZappersTokens = this.extraZappers.values().flatMap((l) => l.flatMap((z) => [z.tokenIn, z.tokenOut]));
+    for (const t of [...zappersTokens, ...extraZappersTokens]) {
+      this.sdk.tokensMeta.upsert(t.addr, t);
+      this.sdk.setAddressLabel(t.addr, t.symbol);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ZappersPlugin
+});