@gearbox-protocol/sdk 13.0.0-next.9 → 13.1.0-next.1

package/dist/cjs/sdk/accounts/CreditAccountsServiceV310.js

@@ -65,7 +65,7 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
       })
     };
     const calls = [...priceUpdatesCalls, addBotCall];
-    const tx = targetContract.type === "creditAccount" ? cm.creditFacade.multicall(targetContract.creditAccount, calls) : void 0;
+    const tx = targetContract.type === "creditAccount" ? await this.multicallTx(cm, targetContract.creditAccount, calls) : void 0;
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
@@ -100,7 +100,7 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
         averageQuota
       })
     ];
-    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    const tx = await this.multicallTx(cm, creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
@@ -113,13 +113,14 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
     creditAccount: ca,
     permits,
     to,
-    tokensToClaim
+    tokensToClaim,
+    calls: wrapCalls = []
   }) {
     const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
     const addCollateral = collateralAssets.filter((a) => a.balance > 0);
     const router = this.sdk.routerFor(ca);
+    const unwrapCalls = await this.getRedeemDiffCalls(1n, ca.creditManager) ?? [];
     const claimPath = await router.findClaimAllRewards({
-      calls: [],
       tokensToClaim,
       creditAccount: ca
     });
@@ -130,15 +131,21 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
     const calls = [
       ...operation === "close" ? [] : priceUpdates,
       ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...wrapCalls,
       ...this.prepareDisableQuotas(ca),
       ...this.prepareDecreaseDebt(ca),
+      ...unwrapCalls,
       ...claimPath.calls,
-      ...this.prepareDisableTokens(ca),
       ...assetsToWithdraw.map(
         (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, import_math.MAX_UINT256, to)
       )
     ];
-    const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
+    const tx = await this.closeCreditAccountTx(
+      cm,
+      ca.creditAccount,
+      calls,
+      operation
+    );
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
@@ -155,7 +162,6 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
     const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
     const router = this.sdk.routerFor(ca);
     const claimPath = await router.findClaimAllRewards({
-      calls: [],
       tokensToClaim,
       creditAccount: ca
     });
@@ -163,11 +169,13 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
       creditManager: ca.creditManager,
       creditAccount: ca
     });
+    const wrapCalls = await this.getDepositDiffCalls(1n, ca.creditManager) ?? [];
     const addCollateral = collateralAssets.filter((a) => a.balance > 0);
     const calls = [
       ...priceUpdates,
       ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
       ...claimPath.calls,
+      ...wrapCalls,
       ...assetsToWithdraw.map(
         (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, import_math.MAX_UINT256, to)
       )
@@ -183,21 +191,23 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
    * Implements {@link ICreditAccountsService.claimFarmRewards}
    */
   async claimFarmRewards({
-    calls: legacyCalls,
+    calls: externalCalls,
     creditAccount: ca,
     minQuota,
     averageQuota,
-    tokensToClaim,
-    forceCalls
+    tokensToClaim
   }) {
     const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
     const router = this.sdk.routerFor(ca);
-    const claimPath = await router.findClaimAllRewards({
-      calls: legacyCalls,
-      tokensToClaim,
-      creditAccount: ca,
-      forceCalls
-    });
+    let claimPath;
+    if (externalCalls) {
+      claimPath = { calls: externalCalls };
+    } else {
+      claimPath = await router.findClaimAllRewards({
+        tokensToClaim,
+        creditAccount: ca
+      });
+    }
     if (claimPath.calls.length === 0) throw new Error("No path to execute");
     const priceUpdatesCalls = await this.getPriceUpdatesForFacade({
       creditManager: ca.creditManager,
@@ -209,7 +219,7 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
       ...claimPath.calls,
       ...this.prepareUpdateQuotas(ca.creditFacade, { minQuota, averageQuota })
     ];
-    const tx = cm.creditFacade.multicall(ca.creditAccount, calls);
+    const tx = await this.multicallTx(cm, ca.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   async previewWithdrawLlamathenaProportionally(_) {

package/dist/cjs/sdk/accounts/createCreditAccountService.js

@@ -22,12 +22,8 @@ __export(createCreditAccountService_exports, {
 });
 module.exports = __toCommonJS(createCreditAccountService_exports);
 var import_constants = require("../constants/index.js");
-var import_CreditAccountsServiceV300 = require("./CreditAccountsServiceV300.js");
 var import_CreditAccountsServiceV310 = require("./CreditAccountsServiceV310.js");
 function createCreditAccountService(sdk, version, options) {
-  if ((0, import_constants.isV300)(version)) {
-    return new import_CreditAccountsServiceV300.CreditAccountServiceV300(sdk, options);
-  }
   if ((0, import_constants.isV310)(version)) {
     return new import_CreditAccountsServiceV310.CreditAccountServiceV310(sdk, options);
   }

package/dist/cjs/sdk/accounts/index.js

@@ -16,14 +16,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var accounts_exports = {};
 module.exports = __toCommonJS(accounts_exports);
 __reExport(accounts_exports, require("./AbstractCreditAccountsService.js"), module.exports);
-__reExport(accounts_exports, require("./CreditAccountsServiceV300.js"), module.exports);
 __reExport(accounts_exports, require("./CreditAccountsServiceV310.js"), module.exports);
 __reExport(accounts_exports, require("./createCreditAccountService.js"), module.exports);
 __reExport(accounts_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./AbstractCreditAccountsService.js"),
-  ...require("./CreditAccountsServiceV300.js"),
   ...require("./CreditAccountsServiceV310.js"),
   ...require("./createCreditAccountService.js"),
   ...require("./types.js")

package/dist/cjs/sdk/base/BaseContract.js

@@ -51,15 +51,15 @@ class BaseContract extends import_Construct.Construct {
   version;
   address;
   name;
-  constructor({ client, logger }, args) {
-    super({ client, logger });
+  constructor(options, args) {
+    super(options);
     this.abi = args.abi;
     this.address = (0, import_viem.getAddress)(args.addr);
     this.contract = (0, import_viem.getContract)({
       address: this.address,
       // add exceptions for better error decoding
       abi: [...this.abi, ...import_errors.errorAbis],
-      client
+      client: this.client
     });
     this.version = Number(args.version || 0);
     this.contractType = args.contractType ?? "";
@@ -67,8 +67,11 @@ class BaseContract extends import_Construct.Construct {
       this.contractType = (0, import_utils.bytes32ToString)(this.contractType);
     }
     this.name = args.name || this.contractType || this.address || this.constructor.name;
-    this.register.setContract(this.address, this);
-    this.register.setAddressLabel(this.address, this.name);
+    const register = this.safeGetRegister();
+    if (register) {
+      register.setContract(this.address, this);
+      register.setAddressLabel(this.address, this.name);
+    }
   }
   stateHuman(_ = true) {
     return {
@@ -202,11 +205,62 @@ class BaseContract extends import_Construct.Construct {
       chainId: this.chainId,
       target: this.address,
       contractType: this.contractType,
-      label: this.register.labelAddress(this.address, true),
+      label: this.labelAddress(this.address, true),
       functionName,
       args
     };
   }
+  /**
+   * Parses calldata into structured result with preserved original types.
+   * When strict is true, throws {@link ContractParseError} on unknown selectors;
+   * otherwise returns a fallback with the raw calldata.
+   */
+  parseFunctionDataV2(calldata, strict) {
+    try {
+      const decoded = (0, import_viem.decodeFunctionData)({
+        abi: this.abi,
+        data: calldata
+      });
+      const functionName = (0, import_utils.getFunctionSignature)(this.abi, calldata);
+      return this.wrapParseCallV2(
+        functionName,
+        this.parseFunctionParamsV2(decoded, strict)
+      );
+    } catch (e) {
+      if (strict) {
+        throw new ContractParseError(e, {
+          address: this.address,
+          callData: calldata,
+          contractName: this.name
+        });
+      }
+      this.logger?.warn(e);
+      const selector = calldata.slice(0, 10);
+      const data = `0x${calldata.slice(10)}`;
+      return this.wrapParseCallV2(`unknown function ${selector}`, {
+        _data: data
+      });
+    }
+  }
+  /**
+   * Converts viem-decoded function arguments to a record preserving original types.
+   * Override in subclasses to handle nesting (e.g., multicall inner calls).
+   * @param strict - propagated from parseFunctionDataV2 for recursive parsing
+   */
+  parseFunctionParamsV2(params, _strict) {
+    return (0, import_utils.functionArgsToRecord)(this.abi, params.functionName, params.args);
+  }
+  wrapParseCallV2(functionName, rawArgs) {
+    return {
+      chainId: this.chainId,
+      target: this.address,
+      contractType: this.contractType,
+      label: this.labelAddress(this.address, true),
+      version: this.version,
+      functionName,
+      rawArgs
+    };
+  }
   /**
    * Creates a raw transaction for a function in this contract
    * @param parameters

package/dist/cjs/sdk/base/ChainContractsRegister.js

@@ -25,16 +25,6 @@ var import_addresses = require("../constants/addresses.js");
 var import_AddressMap = require("../utils/AddressMap.js");
 var import_TokensMeta = require("./TokensMeta.js");
 class ChainContractsRegister {
-  static #chains = /* @__PURE__ */ new Map();
-  static for(client, logger) {
-    const chainId = client.chain.id;
-    let result = ChainContractsRegister.#chains.get(chainId);
-    if (!result) {
-      result = new ChainContractsRegister(client, logger);
-      ChainContractsRegister.#chains.set(chainId, result);
-    }
-    return result;
-  }
   contracts = new import_AddressMap.AddressMap(
     [],
     "contracts"
@@ -48,7 +38,7 @@ class ChainContractsRegister {
   logger;
   constructor(client, logger) {
     this.client = client;
-    this.tokensMeta = new import_TokensMeta.TokensMeta(client);
+    this.tokensMeta = new import_TokensMeta.TokensMeta(client, logger);
     this.logger = logger;
   }
   resetContracts() {
@@ -136,6 +126,39 @@ class ChainContractsRegister {
       (call) => this.parseFunctionData(call.target, call.callData)
     );
   }
+  /**
+   * Parses calldata for a contract at the given address, preserving original types.
+   * When strict is true, throws on unknown address or selector; otherwise returns a fallback.
+   */
+  parseFunctionDataV2(address, calldata, strict) {
+    const contract = this.contracts.get(address);
+    if (contract) {
+      return contract.parseFunctionDataV2(calldata, strict);
+    }
+    if (strict) {
+      throw new Error(`contract ${address} not found on chain ${this.chainId}`);
+    }
+    const selector = calldata.slice(0, 10);
+    const data = `0x${calldata.slice(10)}`;
+    return {
+      chainId: this.chainId,
+      target: address,
+      contractType: "",
+      label: this.labelAddress(address, true),
+      version: 0,
+      functionName: `unknown function ${selector}`,
+      rawArgs: { _data: data }
+    };
+  }
+  /**
+   * Parses multicalls preserving original types.
+   * When strict is true, throws on unknown targets or selectors.
+   */
+  parseMultiCallV2(calls, strict) {
+    return calls.map(
+      (call) => this.parseFunctionDataV2(call.target, call.callData, strict)
+    );
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/sdk/base/Construct.js

@@ -26,19 +26,41 @@ var import_ChainContractsRegister = require("./ChainContractsRegister.js");
 class Construct {
   logger;
   client;
-  register;
+  #register;
   /**
    * Indicates that contract state needs to be updated
    */
   #dirty = false;
-  constructor({ client, logger }) {
-    this.client = client;
-    this.register = import_ChainContractsRegister.ChainContractsRegister.for(client, logger);
+  constructor(options) {
+    if (options instanceof import_ChainContractsRegister.ChainContractsRegister) {
+      this.#register = options;
+      this.client = options.client;
+    } else if ("register" in options) {
+      this.#register = options.register;
+      this.client = options.register.client;
+    } else {
+      this.client = options.client;
+    }
     this.logger = (0, import_utils.childLogger)(
       this.constructor.name,
-      this.register.logger ?? logger
+      this.#register?.logger ?? options.logger
     );
   }
+  /**
+   * Throws if register was not provided in constructor options
+   * Ephemeral contracts that do not need to access other contracts may not need it
+   */
+  get register() {
+    if (!this.#register) {
+      throw new Error(
+        "contracts register not available, it must be provided if contract needs to access other contracts"
+      );
+    }
+    return this.#register;
+  }
+  safeGetRegister() {
+    return this.#register;
+  }
   get chain() {
     return this.client.chain;
   }
@@ -60,19 +82,11 @@ class Construct {
   set dirty(value) {
     this.#dirty = value;
   }
-  /**
-   * Syntax sugar for rgister.tokensMeta
-   */
   get tokensMeta() {
     return this.register.tokensMeta;
   }
-  /**
-   * Syntax suggar for getting contract labels
-   * @param address
-   * @returns
-   */
-  labelAddress(address) {
-    return this.register.labelAddress(address);
+  labelAddress(address, omitAddress) {
+    return this.#register?.labelAddress(address, omitAddress) ?? address;
   }
   /**
    * Returns list of addresses that should be watched for events to sync state

package/dist/cjs/sdk/base/PlaceholderContract.js

@@ -24,8 +24,8 @@ module.exports = __toCommonJS(PlaceholderContract_exports);
 var import_BaseContract = require("./BaseContract.js");
 const abi = [];
 class PlaceholderContract extends import_BaseContract.BaseContract {
-  constructor(sdk, args) {
-    super(sdk, { ...args, abi });
+  constructor(options, args) {
+    super(options, { ...args, abi });
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/sdk/base/SDKConstruct.js

@@ -25,7 +25,7 @@ var import_Construct = require("./Construct.js");
 class SDKConstruct extends import_Construct.Construct {
   sdk;
   constructor(sdk) {
-    super(sdk);
+    super({ register: sdk });
     this.sdk = sdk;
   }
 }

package/dist/cjs/sdk/base/TokensMeta.js

@@ -22,46 +22,84 @@ __export(TokensMeta_exports, {
 });
 module.exports = __toCommonJS(TokensMeta_exports);
 var import_viem = require("viem");
+var import_iSecuritizeDegenNFT = require("../../abi/310/iSecuritizeDegenNFT.js");
+var import_iSecuritizeKYCFactory = require("../../abi/310/iSecuritizeKYCFactory.js");
 var import_iStateSerializer = require("../../abi/iStateSerializer.js");
 var import_iVersion = require("../../abi/iVersion.js");
-var import__ = require("../index.js");
 var import_utils = require("../utils/index.js");
+var import_token_types = require("./token-types.js");
 class TokensMeta extends import_utils.AddressMap {
   #client;
   #tokenDataLoaded = new import_utils.AddressSet();
-  constructor(client) {
+  #logger;
+  constructor(client, logger) {
     super(void 0, "tokensMeta");
     this.#client = client;
+    this.#logger = logger?.child?.({ name: "TokensMeta" }) ?? logger;
   }
   reset() {
     this.clear();
     this.#tokenDataLoaded.clear();
   }
+  upsert(address, value) {
+    let v = value;
+    const existing = this.get(address);
+    if (existing && v) {
+      v = {
+        ...existing,
+        ...v
+      };
+    }
+    super.upsert(address, v);
+  }
   symbol(token) {
     return this.mustGet(token).symbol;
   }
   decimals(token) {
     return this.mustGet(token).decimals;
   }
+  /**
+   * Returns true if the token is a phantom token, throws if the token data is not loaded
+   * @param t
+   * @returns
+   */
   isPhantomToken(t) {
     if (!this.#tokenDataLoaded.has(t.addr)) {
       throw new Error(
         `extended token data not loaded for ${t.symbol} (${t.addr})`
       );
     }
-    return "contractType" in t && t.contractType.startsWith("PHANTOM_TOKEN::");
+    return !!t.contractType?.startsWith("PHANTOM_TOKEN::");
   }
+  /**
+   * Returns true if the token is a KYC underlying token, throws if the token data is not loaded
+   * @param t
+   * @returns
+   */
   isKYCUnderlying(t) {
     if (!this.#tokenDataLoaded.has(t.addr)) {
       throw new Error(
         `extended token data not loaded for ${t.symbol} (${t.addr})`
       );
     }
-    return "contractType" in t && t.contractType.startsWith("KYC_UNDERLYING::");
+    return !!t.contractType?.startsWith("KYC_UNDERLYING::");
+  }
+  /**
+   * Returns true if the token is a DSToken, throws if the token data is not loaded
+   * @param t
+   * @returns
+   */
+  isDSToken(t) {
+    if (!this.#tokenDataLoaded.has(t.addr)) {
+      throw new Error(
+        `extended token data not loaded for ${t.symbol} (${t.addr})`
+      );
+    }
+    return !!t.isDSToken;
   }
   /**
    * Returns a map of all phantom tokens
-   * Throws if the phantom token data is not loaded
+   * Throws if token data is not loaded
    */
   get phantomTokens() {
     const result = new import_utils.AddressMap();
@@ -72,6 +110,10 @@ class TokensMeta extends import_utils.AddressMap {
     }
     return result;
   }
+  /**
+   * Returns a map of all KYC underlying tokens
+   * Throws if token data is not loaded
+   */
   get kycUnderlyings() {
     const result = new import_utils.AddressMap();
     for (const [token, meta] of this.entries()) {
@@ -81,6 +123,15 @@ class TokensMeta extends import_utils.AddressMap {
     }
     return result;
   }
+  get dsTokens() {
+    const result = new import_utils.AddressMap();
+    for (const [token, meta] of this.entries()) {
+      if (this.isDSToken(meta)) {
+        result.upsert(token, meta);
+      }
+    }
+    return result;
+  }
   formatBN(arg0, arg1, arg2) {
     const token = typeof arg0 === "object" ? arg0.token : arg0;
     const amount = typeof arg0 === "object" ? arg0.balance : arg1;
@@ -100,7 +151,7 @@ class TokensMeta extends import_utils.AddressMap {
     return meta;
   }
   /**
-   * Loads token information about phantom token and KYC underlying tokens
+   * Loads token information about phantom tokens, KYC underlying tokens and DSTokens
    *
    * @param tokens - tokens to load data for, defaults to all tokens
    */
@@ -128,15 +179,26 @@ class TokensMeta extends import_utils.AddressMap {
       allowFailure: true,
       batchSize: 0
     });
+    this.#logger?.debug(`loaded ${resp.length} contract types`);
+    const kycFactories = new import_utils.AddressSet();
     for (let i = 0; i < tokensToLoad.length; i++) {
-      this.#overrideTokenMeta(tokensToLoad[i], resp[i], resp[i + 1]);
+      const meta = this.#overrideTokenMeta(
+        tokensToLoad[i],
+        resp[2 * i],
+        resp[2 * i + 1]
+      );
       this.#tokenDataLoaded.add(tokensToLoad[i]);
+      if (this.isKYCUnderlying(meta)) {
+        kycFactories.add(meta.kycFactory);
+      }
     }
+    this.#logger?.debug(`found ${kycFactories.size} KYC factories`);
+    await this.#loadDSTokens(kycFactories);
   }
   #overrideTokenMeta(token, contractTypeResp, serializeResp) {
     const meta = this.mustGet(token);
     if (contractTypeResp.status === "success") {
-      const contractType = (0, import__.bytes32ToString)(contractTypeResp.result);
+      const contractType = (0, import_utils.bytes32ToString)(contractTypeResp.result);
       if (contractType.startsWith("KYC_UNDERLYING::")) {
         if (serializeResp.status === "success") {
           this.#overrideKYCUnderlying(meta, contractType, serializeResp.result);
@@ -145,16 +207,18 @@ class TokensMeta extends import_utils.AddressMap {
             `token ${meta.symbol} (${token}) is ${contractType} but serialize failed: ${serializeResp.error}`
           );
         }
-      } else if (contractType.startsWith("PHANTOM_TOKEN::")) {
+      } else {
         this.upsert(token, {
           ...meta,
           contractType
         });
       }
+      this.#logger?.debug(`token ${meta.symbol} is ${contractType}`);
     }
+    return this.mustGet(token);
   }
   #overrideKYCUnderlying(meta, contractType, serialized) {
-    if (contractType === import__.KYC_UNDERLYING_DEFAULT) {
+    if (contractType === import_token_types.KYC_UNDERLYING_DEFAULT) {
       const decoded = (0, import_viem.decodeAbiParameters)(
         [
           { type: "address", name: "kycFactory" },
@@ -168,7 +232,7 @@ class TokensMeta extends import_utils.AddressMap {
         kycFactory: decoded[0],
         asset: decoded[1]
       });
-    } else if (contractType === import__.KYC_UNDERLYING_ON_DEMAND) {
+    } else if (contractType === import_token_types.KYC_UNDERLYING_ON_DEMAND) {
       const decoded = (0, import_viem.decodeAbiParameters)(
         [
           { type: "address", name: "kycFactory" },
@@ -188,6 +252,85 @@ class TokensMeta extends import_utils.AddressMap {
       });
     }
   }
+  async #loadDSTokens(kycFactories) {
+    const degenNFTs = await this.#client.multicall({
+      contracts: kycFactories.map((address) => {
+        return {
+          address,
+          abi: import_iSecuritizeKYCFactory.iSecuritizeKYCFactoryAbi,
+          functionName: "getDegenNFT"
+        };
+      }),
+      allowFailure: false,
+      batchSize: 0
+    });
+    const resp = await this.#client.multicall({
+      contracts: degenNFTs.map((address) => {
+        return {
+          address,
+          abi: import_iSecuritizeDegenNFT.iSecuritizeDegenNFTAbi,
+          functionName: "getDSTokens"
+        };
+      }),
+      allowFailure: false,
+      batchSize: 0
+    });
+    const dsToken = new import_utils.AddressSet(resp.flat());
+    const tokensToLoad = dsToken.difference(new Set(this.keys()));
+    this.#logger?.debug(
+      `found ${dsToken.size} DSTokens in KYC factories, need to load ${tokensToLoad.size} basic metadata`
+    );
+    await this.#loadWithoutCompressor(tokensToLoad);
+    for (const token of dsToken) {
+      const meta = this.mustGet(token);
+      this.upsert(token, {
+        ...meta,
+        isDSToken: true
+      });
+      this.#tokenDataLoaded.add(token);
+      this.#logger?.debug(`token ${meta.symbol} (${token}) is a DSToken`);
+    }
+  }
+  async #loadWithoutCompressor(tokens_) {
+    if (tokens_.size === 0) {
+      return;
+    }
+    const tokens = Array.from(tokens_);
+    const resp = await this.#client.multicall({
+      contracts: tokens.flatMap(
+        (t) => [
+          {
+            address: t,
+            abi: import_viem.erc20Abi,
+            functionName: "symbol"
+          },
+          {
+            address: t,
+            abi: import_viem.erc20Abi,
+            functionName: "name"
+          },
+          {
+            address: t,
+            abi: import_viem.erc20Abi,
+            functionName: "decimals"
+          }
+        ]
+      ),
+      allowFailure: false,
+      batchSize: 0
+    });
+    this.#logger?.debug(
+      `loaded ${resp.length} basic metadata without compressor`
+    );
+    for (let i = 0; i < tokens.length; i++) {
+      this.upsert(tokens[i], {
+        addr: tokens[i],
+        symbol: resp[3 * i],
+        name: resp[3 * i + 1],
+        decimals: resp[3 * i + 2]
+      });
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {