@gearbox-protocol/sdk 3.0.0-vfour.3 → 3.0.0-vfour.5

package/dist/cjs/index.cjs

@@ -1,266 +1,17 @@
 'use strict';
 
-var sdkGov = require('@gearbox-protocol/sdk-gov');
 var viem = require('viem');
 var utils = require('viem/utils');
+var dateFns = require('date-fns');
 var chains$1 = require('viem/chains');
+var actions = require('viem/actions');
 var eventemitter3 = require('eventemitter3');
 var evmConnector = require('@redstone-finance/evm-connector');
 var redstoneProtocol = require('redstone-protocol');
+var sdkGov = require('@gearbox-protocol/sdk-gov');
 var aura = require('@gearbox-protocol/sdk-gov/lib/tokens/aura');
 
-// src/base/AddressLabeller.ts
-
-// src/constants/addresses.ts
-var ADDRESS_0X0 = "0x0000000000000000000000000000000000000000";
-var NOT_DEPLOYED = "0xNOT DEPLOYED";
-
-// src/constants/address-provider.ts
-var NO_VERSION = 0;
-var AP_ACL = "ACL";
-var AP_CONTRACTS_REGISTER = "CONTRACTS_REGISTER";
-var AP_PRICE_ORACLE = "PRICE_ORACLE";
-var AP_ACCOUNT_FACTORY = "ACCOUNT_FACTORY";
-var AP_DATA_COMPRESSOR = "DATA_COMPRESSOR";
-var AP_MARKET_COMPRESSOR = "MARKET_COMPRESSOR";
-var AP_CREDIT_ACCOUNT_COMPRESSOR = "CREDIT_ACCOUNT_COMPRESSOR";
-var AP_TREASURY = "TREASURY";
-var AP_GEAR_TOKEN = "GEAR_TOKEN";
-var AP_WETH_TOKEN = "WETH_TOKEN";
-var AP_WETH_GATEWAY = "WETH_GATEWAY";
-var AP_ROUTER = "ROUTER";
-var AP_BOT_LIST = "BOT_LIST";
-var AP_GEAR_STAKING = "GEAR_STAKING";
-var AP_ZAPPER_REGISTER = "ZAPPER_REGISTER";
-var AP_CONTROLLER_TIMELOCK = "CONTROLLER_TIMELOCK";
-var AP_DEGEN_NFT = "DEGEN_NFT";
-var AP_ZERO_PRICE_FEED = "ZERO_PRICE_FEED";
-var AP_DEGEN_DISTRIBUTOR = "DEGEN_DISTRIBUTOR";
-var AP_MULTI_PAUSE = "MULTI_PAUSE";
-var AP_INFLATION_ATTACK_BLOCKER = "INFLATION_ATTACK_BLOCKER";
-var AP_INSOLVENCY_CHECKER = "INSOLVENCY_CHECKER";
-var AP_PARTIAL_LIQUIDATION_BOT = "PARTIAL_LIQUIDATION_BOT";
-var AP_DELEVERAGE_BOT_PEGGED = "DELEVERAGE_BOT_PEGGED";
-var AP_DELEVERAGE_BOT_LV = "DELEVERAGE_BOT_LV";
-var AP_DELEVERAGE_BOT_HV = "DELEVERAGE_BOT_HV";
-var ADDRESS_PROVIDER = {
-  Mainnet: "0x9ea7b04Da02a5373317D745c1571c84aaD03321D",
-  Arbitrum: "0x7d04eCdb892Ae074f03B5D0aBA03796F90F3F2af",
-  Optimism: "0x3761ca4BFAcFCFFc1B8034e69F19116dD6756726",
-  Base: NOT_DEPLOYED
-};
-var AddressMap = class {
-  #map;
-  #frozen = false;
-  constructor(entries) {
-    this.#map = /* @__PURE__ */ new Map();
-    if (entries) {
-      for (const [address, value] of entries) {
-        const key = address.toLowerCase();
-        if (!viem.isAddress(key)) {
-          throw new Error(`value "${address}" is not an address`);
-        }
-        this.#map.set(key, value);
-      }
-    }
-  }
-  /**
-   * Adds or updates value
-   * @param address
-   * @param value
-   */
-  upsert(address, value) {
-    if (this.#frozen) {
-      throw new Error(`AddressMap is frozen`);
-    }
-    const key = address.toLowerCase();
-    if (!viem.isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
-    this.#map.set(key, value);
-  }
-  /**
-   * Adds value, throws if this address is already used
-   * @param address
-   * @param value
-   */
-  insert(address, value) {
-    if (this.#frozen) {
-      throw new Error(`AddressMap is frozen`);
-    }
-    const key = address.toLowerCase();
-    if (!viem.isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
-    if (this.#map.has(key)) {
-      throw new Error(`address ${address} already exists`);
-    }
-    this.#map.set(key, value);
-  }
-  /**
-   * Checks if address is present in map
-   * @param address
-   * @returns
-   */
-  has(address) {
-    const key = address.toLowerCase();
-    if (!viem.isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
-    return this.#map.has(key);
-  }
-  /**
-   * Returns value, or undefined if the address is not in map
-   * @param address
-   * @returns
-   */
-  get(address) {
-    const key = address.toLowerCase();
-    if (!viem.isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
-    return this.#map.get(key);
-  }
-  /**
-   * Gets address from map, throws if not found
-   * @param address
-   * @returns
-   */
-  mustGet(address) {
-    const v = this.get(address);
-    if (!v) {
-      throw new Error(`address ${address} not found in map`);
-    }
-    return v;
-  }
-  entries() {
-    return this.#map.entries();
-  }
-  values() {
-    return this.#map.values();
-  }
-  asRecord() {
-    return Object.fromEntries(this.#map.entries());
-  }
-  freeze() {
-    this.#frozen = true;
-  }
-};
-function bytes32ToString(bytes) {
-  return viem.bytesToString(viem.toBytes(bytes)).replaceAll("\0", "");
-}
-
-// src/utils/childLogger.ts
-function childLogger(module, logger) {
-  return logger?.child?.({ module }) ?? logger;
-}
-
-// src/utils/json.ts
-function replacer(_key, value) {
-  if (typeof value === "bigint") {
-    return {
-      __type: "bigint",
-      __value: value.toString()
-    };
-  } else {
-    return value;
-  }
-}
-function reviver(_key, value) {
-  if (value && value.__type === "bigint") {
-    return BigInt(value.__value);
-  }
-  return value;
-}
-var json_stringify = (obj, space = 2) => {
-  return JSON.stringify(obj, replacer, space);
-};
-var json_parse = (s) => {
-  return JSON.parse(s, reviver);
-};
-
-// src/utils/createRawTx.ts
-function createRawTx(to, parameters, description) {
-  const { args } = parameters;
-  const fname = parameters.functionName;
-  const { abi: abi2, functionName } = (() => {
-    if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
-      return parameters;
-    return viem.prepareEncodeFunctionData(parameters);
-  })();
-  const abiItem = abi2[0];
-  const signature = functionName;
-  const data = "inputs" in abiItem && abiItem.inputs ? viem.encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
-  const functionEncodedData = viem.concatHex([signature, data ?? "0x"]);
-  const inputs = "inputs" in abiItem && abiItem.inputs ? [...abiItem.inputs] : [];
-  const payable = "payble" in abiItem ? abiItem.payble === true : false;
-  const contractInputsValues = {};
-  if (inputs.length > 0 && args && args.length !== 0) {
-    args.forEach((arg, i) => {
-      const methodName = inputs[i].name;
-      let stringifiedArg = arg instanceof BigInt ? arg.toString() : arg;
-      contractInputsValues[methodName] = Array.isArray(stringifiedArg) ? json_stringify(stringifiedArg) : stringifiedArg;
-    });
-  }
-  return {
-    to,
-    value: "0",
-    contractMethod: {
-      inputs,
-      name: fname,
-      payable
-    },
-    signature: utils.formatAbiItem(abiItem),
-    callData: functionEncodedData,
-    contractInputsValues,
-    description
-  };
-}
-
-// src/base/AddressLabeller.ts
-var AddressLabeller = class {
-  #labels = new AddressMap();
-  set(address, label) {
-    if (address === NOT_DEPLOYED) {
-      return;
-    }
-    if (typeof label === "string") {
-      this.#labels.upsert(address, label);
-    } else {
-      this.#labels.upsert(address, label(this.#labels.get(address)));
-    }
-  }
-  get(address) {
-    const label = this.#labels.get(address);
-    return label ? `${address} [${label}]` : address;
-  }
-  get all() {
-    return this.#labels.asRecord();
-  }
-};
-function initLegacyLabels(labeller, network) {
-  Object.entries(sdkGov.tokenDataByNetwork[network]).forEach(([label, address]) => {
-    labeller.set(address, label);
-  });
-  Object.entries(sdkGov.tickerTokensByNetwork[network]).forEach(([label, address]) => {
-    labeller.set(address, label);
-  });
-  Object.entries(sdkGov.contractsByNetwork[network]).forEach(([label, address]) => {
-    labeller.set(address, label);
-  });
-  const multisigs = [
-    { safe: sdkGov.MULTISIG, label: "Multisig" },
-    { safe: sdkGov.ROUTER_MULTISIG_ADDRESS, label: "RouterMultisig" },
-    { safe: sdkGov.VETO_ADMIN, label: "VetoAdmin" },
-    { safe: sdkGov.TREASURY, label: "Treasury" }
-  ];
-  multisigs.forEach(({ safe, label }) => {
-    labeller.set(safe[network], label);
-  });
-  sdkGov.emergencyLiquidators.forEach((address) => {
-    labeller.set(address, "EmergencyLiquidator");
-  });
-}
+// src/accounts/CreditAccountsService.ts
 
 // src/abi/compressors.ts
 var iAddressProviderV3_1Abi = [
@@ -458,27 +209,410 @@ var iAddressProviderV3_1Abi = [
         indexed: true
       }
     ],
-    name: "RemoveMarketConfigurator"
+    name: "RemoveMarketConfigurator"
+  },
+  {
+    type: "event",
+    anonymous: false,
+    inputs: [
+      { name: "key", internalType: "string", type: "string", indexed: false },
+      {
+        name: "value",
+        internalType: "address",
+        type: "address",
+        indexed: true
+      },
+      {
+        name: "version",
+        internalType: "uint256",
+        type: "uint256",
+        indexed: false
+      }
+    ],
+    name: "SetAddress"
+  }
+];
+var iCreditAccountCompressorAbi = [
+  {
+    type: "function",
+    inputs: [],
+    name: "contractType",
+    outputs: [{ name: "", internalType: "bytes32", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "creditManager", internalType: "address", type: "address" },
+      {
+        name: "caFilter",
+        internalType: "struct CreditAccountFilter",
+        type: "tuple",
+        components: [
+          { name: "owner", internalType: "address", type: "address" },
+          { name: "includeZeroDebt", internalType: "bool", type: "bool" },
+          { name: "minHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "maxHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "reverting", internalType: "bool", type: "bool" }
+        ]
+      }
+    ],
+    name: "countCreditAccounts",
+    outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [
+      {
+        name: "cmFilter",
+        internalType: "struct MarketFilter",
+        type: "tuple",
+        components: [
+          { name: "curators", internalType: "address[]", type: "address[]" },
+          { name: "pools", internalType: "address[]", type: "address[]" },
+          { name: "underlying", internalType: "address", type: "address" }
+        ]
+      },
+      {
+        name: "caFilter",
+        internalType: "struct CreditAccountFilter",
+        type: "tuple",
+        components: [
+          { name: "owner", internalType: "address", type: "address" },
+          { name: "includeZeroDebt", internalType: "bool", type: "bool" },
+          { name: "minHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "maxHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "reverting", internalType: "bool", type: "bool" }
+        ]
+      }
+    ],
+    name: "countCreditAccounts",
+    outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "creditAccount", internalType: "address", type: "address" }
+    ],
+    name: "getCreditAccountData",
+    outputs: [
+      {
+        name: "",
+        internalType: "struct CreditAccountData",
+        type: "tuple",
+        components: [
+          { name: "creditAccount", internalType: "address", type: "address" },
+          { name: "creditManager", internalType: "address", type: "address" },
+          { name: "creditFacade", internalType: "address", type: "address" },
+          { name: "underlying", internalType: "address", type: "address" },
+          { name: "owner", internalType: "address", type: "address" },
+          {
+            name: "enabledTokensMask",
+            internalType: "uint256",
+            type: "uint256"
+          },
+          { name: "debt", internalType: "uint256", type: "uint256" },
+          { name: "accruedInterest", internalType: "uint256", type: "uint256" },
+          { name: "accruedFees", internalType: "uint256", type: "uint256" },
+          { name: "totalDebtUSD", internalType: "uint256", type: "uint256" },
+          { name: "totalValueUSD", internalType: "uint256", type: "uint256" },
+          { name: "twvUSD", internalType: "uint256", type: "uint256" },
+          { name: "totalValue", internalType: "uint256", type: "uint256" },
+          { name: "healthFactor", internalType: "uint16", type: "uint16" },
+          { name: "success", internalType: "bool", type: "bool" },
+          {
+            name: "tokens",
+            internalType: "struct TokenInfo[]",
+            type: "tuple[]",
+            components: [
+              { name: "token", internalType: "address", type: "address" },
+              { name: "mask", internalType: "uint256", type: "uint256" },
+              { name: "balance", internalType: "uint256", type: "uint256" },
+              { name: "quota", internalType: "uint256", type: "uint256" },
+              { name: "success", internalType: "bool", type: "bool" }
+            ]
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [
+      {
+        name: "cmFilter",
+        internalType: "struct MarketFilter",
+        type: "tuple",
+        components: [
+          { name: "curators", internalType: "address[]", type: "address[]" },
+          { name: "pools", internalType: "address[]", type: "address[]" },
+          { name: "underlying", internalType: "address", type: "address" }
+        ]
+      },
+      {
+        name: "caFilter",
+        internalType: "struct CreditAccountFilter",
+        type: "tuple",
+        components: [
+          { name: "owner", internalType: "address", type: "address" },
+          { name: "includeZeroDebt", internalType: "bool", type: "bool" },
+          { name: "minHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "maxHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "reverting", internalType: "bool", type: "bool" }
+        ]
+      },
+      { name: "offset", internalType: "uint256", type: "uint256" }
+    ],
+    name: "getCreditAccounts",
+    outputs: [
+      {
+        name: "data",
+        internalType: "struct CreditAccountData[]",
+        type: "tuple[]",
+        components: [
+          { name: "creditAccount", internalType: "address", type: "address" },
+          { name: "creditManager", internalType: "address", type: "address" },
+          { name: "creditFacade", internalType: "address", type: "address" },
+          { name: "underlying", internalType: "address", type: "address" },
+          { name: "owner", internalType: "address", type: "address" },
+          {
+            name: "enabledTokensMask",
+            internalType: "uint256",
+            type: "uint256"
+          },
+          { name: "debt", internalType: "uint256", type: "uint256" },
+          { name: "accruedInterest", internalType: "uint256", type: "uint256" },
+          { name: "accruedFees", internalType: "uint256", type: "uint256" },
+          { name: "totalDebtUSD", internalType: "uint256", type: "uint256" },
+          { name: "totalValueUSD", internalType: "uint256", type: "uint256" },
+          { name: "twvUSD", internalType: "uint256", type: "uint256" },
+          { name: "totalValue", internalType: "uint256", type: "uint256" },
+          { name: "healthFactor", internalType: "uint16", type: "uint16" },
+          { name: "success", internalType: "bool", type: "bool" },
+          {
+            name: "tokens",
+            internalType: "struct TokenInfo[]",
+            type: "tuple[]",
+            components: [
+              { name: "token", internalType: "address", type: "address" },
+              { name: "mask", internalType: "uint256", type: "uint256" },
+              { name: "balance", internalType: "uint256", type: "uint256" },
+              { name: "quota", internalType: "uint256", type: "uint256" },
+              { name: "success", internalType: "bool", type: "bool" }
+            ]
+          }
+        ]
+      },
+      { name: "nextOffset", internalType: "uint256", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "creditManager", internalType: "address", type: "address" },
+      {
+        name: "caFilter",
+        internalType: "struct CreditAccountFilter",
+        type: "tuple",
+        components: [
+          { name: "owner", internalType: "address", type: "address" },
+          { name: "includeZeroDebt", internalType: "bool", type: "bool" },
+          { name: "minHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "maxHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "reverting", internalType: "bool", type: "bool" }
+        ]
+      },
+      { name: "offset", internalType: "uint256", type: "uint256" }
+    ],
+    name: "getCreditAccounts",
+    outputs: [
+      {
+        name: "data",
+        internalType: "struct CreditAccountData[]",
+        type: "tuple[]",
+        components: [
+          { name: "creditAccount", internalType: "address", type: "address" },
+          { name: "creditManager", internalType: "address", type: "address" },
+          { name: "creditFacade", internalType: "address", type: "address" },
+          { name: "underlying", internalType: "address", type: "address" },
+          { name: "owner", internalType: "address", type: "address" },
+          {
+            name: "enabledTokensMask",
+            internalType: "uint256",
+            type: "uint256"
+          },
+          { name: "debt", internalType: "uint256", type: "uint256" },
+          { name: "accruedInterest", internalType: "uint256", type: "uint256" },
+          { name: "accruedFees", internalType: "uint256", type: "uint256" },
+          { name: "totalDebtUSD", internalType: "uint256", type: "uint256" },
+          { name: "totalValueUSD", internalType: "uint256", type: "uint256" },
+          { name: "twvUSD", internalType: "uint256", type: "uint256" },
+          { name: "totalValue", internalType: "uint256", type: "uint256" },
+          { name: "healthFactor", internalType: "uint16", type: "uint16" },
+          { name: "success", internalType: "bool", type: "bool" },
+          {
+            name: "tokens",
+            internalType: "struct TokenInfo[]",
+            type: "tuple[]",
+            components: [
+              { name: "token", internalType: "address", type: "address" },
+              { name: "mask", internalType: "uint256", type: "uint256" },
+              { name: "balance", internalType: "uint256", type: "uint256" },
+              { name: "quota", internalType: "uint256", type: "uint256" },
+              { name: "success", internalType: "bool", type: "bool" }
+            ]
+          }
+        ]
+      },
+      { name: "nextOffset", internalType: "uint256", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "creditManager", internalType: "address", type: "address" },
+      {
+        name: "caFilter",
+        internalType: "struct CreditAccountFilter",
+        type: "tuple",
+        components: [
+          { name: "owner", internalType: "address", type: "address" },
+          { name: "includeZeroDebt", internalType: "bool", type: "bool" },
+          { name: "minHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "maxHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "reverting", internalType: "bool", type: "bool" }
+        ]
+      },
+      { name: "offset", internalType: "uint256", type: "uint256" },
+      { name: "limit", internalType: "uint256", type: "uint256" }
+    ],
+    name: "getCreditAccounts",
+    outputs: [
+      {
+        name: "data",
+        internalType: "struct CreditAccountData[]",
+        type: "tuple[]",
+        components: [
+          { name: "creditAccount", internalType: "address", type: "address" },
+          { name: "creditManager", internalType: "address", type: "address" },
+          { name: "creditFacade", internalType: "address", type: "address" },
+          { name: "underlying", internalType: "address", type: "address" },
+          { name: "owner", internalType: "address", type: "address" },
+          {
+            name: "enabledTokensMask",
+            internalType: "uint256",
+            type: "uint256"
+          },
+          { name: "debt", internalType: "uint256", type: "uint256" },
+          { name: "accruedInterest", internalType: "uint256", type: "uint256" },
+          { name: "accruedFees", internalType: "uint256", type: "uint256" },
+          { name: "totalDebtUSD", internalType: "uint256", type: "uint256" },
+          { name: "totalValueUSD", internalType: "uint256", type: "uint256" },
+          { name: "twvUSD", internalType: "uint256", type: "uint256" },
+          { name: "totalValue", internalType: "uint256", type: "uint256" },
+          { name: "healthFactor", internalType: "uint16", type: "uint16" },
+          { name: "success", internalType: "bool", type: "bool" },
+          {
+            name: "tokens",
+            internalType: "struct TokenInfo[]",
+            type: "tuple[]",
+            components: [
+              { name: "token", internalType: "address", type: "address" },
+              { name: "mask", internalType: "uint256", type: "uint256" },
+              { name: "balance", internalType: "uint256", type: "uint256" },
+              { name: "quota", internalType: "uint256", type: "uint256" },
+              { name: "success", internalType: "bool", type: "bool" }
+            ]
+          }
+        ]
+      },
+      { name: "nextOffset", internalType: "uint256", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [
+      {
+        name: "cmFilter",
+        internalType: "struct MarketFilter",
+        type: "tuple",
+        components: [
+          { name: "curators", internalType: "address[]", type: "address[]" },
+          { name: "pools", internalType: "address[]", type: "address[]" },
+          { name: "underlying", internalType: "address", type: "address" }
+        ]
+      },
+      {
+        name: "caFilter",
+        internalType: "struct CreditAccountFilter",
+        type: "tuple",
+        components: [
+          { name: "owner", internalType: "address", type: "address" },
+          { name: "includeZeroDebt", internalType: "bool", type: "bool" },
+          { name: "minHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "maxHealthFactor", internalType: "uint16", type: "uint16" },
+          { name: "reverting", internalType: "bool", type: "bool" }
+        ]
+      },
+      { name: "offset", internalType: "uint256", type: "uint256" },
+      { name: "limit", internalType: "uint256", type: "uint256" }
+    ],
+    name: "getCreditAccounts",
+    outputs: [
+      {
+        name: "data",
+        internalType: "struct CreditAccountData[]",
+        type: "tuple[]",
+        components: [
+          { name: "creditAccount", internalType: "address", type: "address" },
+          { name: "creditManager", internalType: "address", type: "address" },
+          { name: "creditFacade", internalType: "address", type: "address" },
+          { name: "underlying", internalType: "address", type: "address" },
+          { name: "owner", internalType: "address", type: "address" },
+          {
+            name: "enabledTokensMask",
+            internalType: "uint256",
+            type: "uint256"
+          },
+          { name: "debt", internalType: "uint256", type: "uint256" },
+          { name: "accruedInterest", internalType: "uint256", type: "uint256" },
+          { name: "accruedFees", internalType: "uint256", type: "uint256" },
+          { name: "totalDebtUSD", internalType: "uint256", type: "uint256" },
+          { name: "totalValueUSD", internalType: "uint256", type: "uint256" },
+          { name: "twvUSD", internalType: "uint256", type: "uint256" },
+          { name: "totalValue", internalType: "uint256", type: "uint256" },
+          { name: "healthFactor", internalType: "uint16", type: "uint16" },
+          { name: "success", internalType: "bool", type: "bool" },
+          {
+            name: "tokens",
+            internalType: "struct TokenInfo[]",
+            type: "tuple[]",
+            components: [
+              { name: "token", internalType: "address", type: "address" },
+              { name: "mask", internalType: "uint256", type: "uint256" },
+              { name: "balance", internalType: "uint256", type: "uint256" },
+              { name: "quota", internalType: "uint256", type: "uint256" },
+              { name: "success", internalType: "bool", type: "bool" }
+            ]
+          }
+        ]
+      },
+      { name: "nextOffset", internalType: "uint256", type: "uint256" }
+    ],
+    stateMutability: "view"
   },
   {
-    type: "event",
-    anonymous: false,
-    inputs: [
-      { name: "key", internalType: "string", type: "string", indexed: false },
-      {
-        name: "value",
-        internalType: "address",
-        type: "address",
-        indexed: true
-      },
-      {
-        name: "version",
-        internalType: "uint256",
-        type: "uint256",
-        indexed: false
-      }
-    ],
-    name: "SetAddress"
+    type: "function",
+    inputs: [],
+    name: "version",
+    outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+    stateMutability: "view"
   }
 ];
 var iMarketCompressorAbi = [
@@ -12275,7 +12409,364 @@ var routerV3Abi = [
     inputs: [{ name: "", internalType: "address", type: "address" }],
     name: "UnsupportedRouterComponent"
   }
-];
+];
+
+// src/constants/addresses.ts
+var ADDRESS_0X0 = "0x0000000000000000000000000000000000000000";
+var NOT_DEPLOYED = "0xNOT DEPLOYED";
+var USDC = {
+  Mainnet: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  Arbitrum: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  Optimism: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+  Base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+};
+var TIMELOCK = {
+  Mainnet: "0xa133C9A92Fb8dDB962Af1cbae58b2723A0bdf23b",
+  Arbitrum: "0x148DD932eCe1155c11006F5650c6Ff428f8D374A",
+  Optimism: "0x148DD932eCe1155c11006F5650c6Ff428f8D374A",
+  Base: NOT_DEPLOYED
+};
+
+// src/constants/address-provider.ts
+var NO_VERSION = 0;
+var AP_ACL = "ACL";
+var AP_CONTRACTS_REGISTER = "CONTRACTS_REGISTER";
+var AP_PRICE_ORACLE = "PRICE_ORACLE";
+var AP_ACCOUNT_FACTORY = "ACCOUNT_FACTORY";
+var AP_DATA_COMPRESSOR = "DATA_COMPRESSOR";
+var AP_MARKET_COMPRESSOR = "MARKET_COMPRESSOR";
+var AP_CREDIT_ACCOUNT_COMPRESSOR = "CREDIT_ACCOUNT_COMPRESSOR";
+var AP_TREASURY = "TREASURY";
+var AP_GEAR_TOKEN = "GEAR_TOKEN";
+var AP_WETH_TOKEN = "WETH_TOKEN";
+var AP_WETH_GATEWAY = "WETH_GATEWAY";
+var AP_ROUTER = "ROUTER";
+var AP_BOT_LIST = "BOT_LIST";
+var AP_GEAR_STAKING = "GEAR_STAKING";
+var AP_ZAPPER_REGISTER = "ZAPPER_REGISTER";
+var AP_CONTROLLER_TIMELOCK = "CONTROLLER_TIMELOCK";
+var AP_DEGEN_NFT = "DEGEN_NFT";
+var AP_ZERO_PRICE_FEED = "ZERO_PRICE_FEED";
+var AP_DEGEN_DISTRIBUTOR = "DEGEN_DISTRIBUTOR";
+var AP_MULTI_PAUSE = "MULTI_PAUSE";
+var AP_INFLATION_ATTACK_BLOCKER = "INFLATION_ATTACK_BLOCKER";
+var AP_INSOLVENCY_CHECKER = "INSOLVENCY_CHECKER";
+var AP_PARTIAL_LIQUIDATION_BOT = "PARTIAL_LIQUIDATION_BOT";
+var AP_DELEVERAGE_BOT_PEGGED = "DELEVERAGE_BOT_PEGGED";
+var AP_DELEVERAGE_BOT_LV = "DELEVERAGE_BOT_LV";
+var AP_DELEVERAGE_BOT_HV = "DELEVERAGE_BOT_HV";
+var ADDRESS_PROVIDER = {
+  Mainnet: "0x9ea7b04Da02a5373317D745c1571c84aaD03321D",
+  Arbitrum: "0x7d04eCdb892Ae074f03B5D0aBA03796F90F3F2af",
+  Optimism: "0x3761ca4BFAcFCFFc1B8034e69F19116dD6756726",
+  Base: NOT_DEPLOYED
+};
+
+// src/constants/bot-permissions.ts
+var BotPermissions = /* @__PURE__ */ ((BotPermissions2) => {
+  BotPermissions2[BotPermissions2["ADD_COLLATERAL"] = 1] = "ADD_COLLATERAL";
+  BotPermissions2[BotPermissions2["INCREASE_DEBT"] = 2] = "INCREASE_DEBT";
+  BotPermissions2[BotPermissions2["DECREASE_DEBT"] = 4] = "DECREASE_DEBT";
+  BotPermissions2[BotPermissions2["ENABLE_TOKEN"] = 8] = "ENABLE_TOKEN";
+  BotPermissions2[BotPermissions2["DISABLE_TOKEN"] = 16] = "DISABLE_TOKEN";
+  BotPermissions2[BotPermissions2["WITHDRAW_COLLATERAL"] = 32] = "WITHDRAW_COLLATERAL";
+  BotPermissions2[BotPermissions2["UPDATE_QUOTA"] = 64] = "UPDATE_QUOTA";
+  BotPermissions2[BotPermissions2["REVOKE_ALLOWANCES"] = 128] = "REVOKE_ALLOWANCES";
+  BotPermissions2[BotPermissions2["EXTERNAL_CALLS"] = 65536] = "EXTERNAL_CALLS";
+  BotPermissions2[BotPermissions2["ALL_CREDIT_FACADE_CALLS"] = 255] = "ALL_CREDIT_FACADE_CALLS";
+  BotPermissions2[BotPermissions2["ALLS"] = 65791] = "ALLS";
+  return BotPermissions2;
+})(BotPermissions || {});
+function botPermissionsToString(value) {
+  let result = "";
+  for (let i = 0; i < 16; i++) {
+    if ((value & 1n << BigInt(i)) !== 0n) {
+      if (result.length > 0) {
+        result += " | ";
+      }
+      result += BotPermissions[1 << i];
+    }
+  }
+  return result;
+}
+
+// src/constants/math.ts
+var MIN_INT96 = -39614081257132168796771975168n;
+var MAX_UINT256 = 115792089237316195423570985008687907853269984665640564039457584007913129639935n;
+var AddressMap = class {
+  #map;
+  #frozen = false;
+  constructor(entries) {
+    this.#map = /* @__PURE__ */ new Map();
+    if (entries) {
+      for (const [address, value] of entries) {
+        const key = address.toLowerCase();
+        if (!viem.isAddress(key)) {
+          throw new Error(`value "${address}" is not an address`);
+        }
+        this.#map.set(key, value);
+      }
+    }
+  }
+  /**
+   * Adds or updates value
+   * @param address
+   * @param value
+   */
+  upsert(address, value) {
+    if (this.#frozen) {
+      throw new Error(`AddressMap is frozen`);
+    }
+    const key = address.toLowerCase();
+    if (!viem.isAddress(key)) {
+      throw new Error(`value "${address}" is not an address`);
+    }
+    this.#map.set(key, value);
+  }
+  /**
+   * Adds value, throws if this address is already used
+   * @param address
+   * @param value
+   */
+  insert(address, value) {
+    if (this.#frozen) {
+      throw new Error(`AddressMap is frozen`);
+    }
+    const key = address.toLowerCase();
+    if (!viem.isAddress(key)) {
+      throw new Error(`value "${address}" is not an address`);
+    }
+    if (this.#map.has(key)) {
+      throw new Error(`address ${address} already exists`);
+    }
+    this.#map.set(key, value);
+  }
+  /**
+   * Checks if address is present in map
+   * @param address
+   * @returns
+   */
+  has(address) {
+    const key = address.toLowerCase();
+    if (!viem.isAddress(key)) {
+      throw new Error(`value "${address}" is not an address`);
+    }
+    return this.#map.has(key);
+  }
+  /**
+   * Returns value, or undefined if the address is not in map
+   * @param address
+   * @returns
+   */
+  get(address) {
+    const key = address.toLowerCase();
+    if (!viem.isAddress(key)) {
+      throw new Error(`value "${address}" is not an address`);
+    }
+    return this.#map.get(key);
+  }
+  /**
+   * Gets address from map, throws if not found
+   * @param address
+   * @returns
+   */
+  mustGet(address) {
+    const v = this.get(address);
+    if (!v) {
+      throw new Error(`address ${address} not found in map`);
+    }
+    return v;
+  }
+  entries() {
+    return this.#map.entries();
+  }
+  values() {
+    return this.#map.values();
+  }
+  asRecord() {
+    return Object.fromEntries(this.#map.entries());
+  }
+  freeze() {
+    this.#frozen = true;
+  }
+};
+function bytes32ToString(bytes) {
+  return viem.bytesToString(viem.toBytes(bytes)).replaceAll("\0", "");
+}
+
+// src/utils/childLogger.ts
+function childLogger(module, logger) {
+  return logger?.child?.({ module }) ?? logger;
+}
+
+// src/utils/json.ts
+function replacer(_key, value) {
+  if (typeof value === "bigint") {
+    return {
+      __type: "bigint",
+      __value: value.toString()
+    };
+  } else {
+    return value;
+  }
+}
+function reviver(_key, value) {
+  if (value && value.__type === "bigint") {
+    return BigInt(value.__value);
+  }
+  return value;
+}
+var json_stringify = (obj, space = 2) => {
+  return JSON.stringify(obj, replacer, space);
+};
+var json_parse = (s) => {
+  return JSON.parse(s, reviver);
+};
+
+// src/utils/createRawTx.ts
+function createRawTx(to, parameters, description) {
+  const { args } = parameters;
+  const fname = parameters.functionName;
+  const { abi: abi2, functionName } = (() => {
+    if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
+      return parameters;
+    return viem.prepareEncodeFunctionData(parameters);
+  })();
+  const abiItem = abi2[0];
+  const signature = functionName;
+  const data = "inputs" in abiItem && abiItem.inputs ? viem.encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
+  const functionEncodedData = viem.concatHex([signature, data ?? "0x"]);
+  const inputs = "inputs" in abiItem && abiItem.inputs ? [...abiItem.inputs] : [];
+  const payable = "payble" in abiItem ? abiItem.payble === true : false;
+  const contractInputsValues = {};
+  if (inputs.length > 0 && args && args.length !== 0) {
+    args.forEach((arg, i) => {
+      const methodName = inputs[i].name;
+      let stringifiedArg = arg instanceof BigInt ? arg.toString() : arg;
+      contractInputsValues[methodName] = Array.isArray(stringifiedArg) ? json_stringify(stringifiedArg) : stringifiedArg;
+    });
+  }
+  return {
+    to,
+    value: "0",
+    contractMethod: {
+      inputs,
+      name: fname,
+      payable
+    },
+    signature: utils.formatAbiItem(abiItem),
+    callData: functionEncodedData,
+    contractInputsValues,
+    description
+  };
+}
+var percentFmt = (v, raw = true) => `${(Number(v) / 100).toFixed(2)}%` + (raw ? ` [${v}]` : "");
+function formatBNvalue(num, decimals2, precision, raw = true) {
+  return `${formatBN(num, decimals2, precision)}` + (raw ? ` [ ${num} ]` : "");
+}
+function formatBN(num, decimals2, precision) {
+  if (num === void 0) {
+    return "-";
+  }
+  const numBInt = BigInt(num);
+  const limitedNum = limitNum(numBInt, decimals2);
+  const limitedPrecision = limitPrecision(limitedNum, precision);
+  return toHumanFormat(limitedNum, limitedPrecision);
+}
+var limitPrecision = (n, p) => {
+  const notZero = n !== 0n;
+  if (n <= 10n && notZero) {
+    return 6;
+  }
+  if (n <= 100n && notZero) {
+    return 5;
+  }
+  if (n <= 1000n && notZero) {
+    return 4;
+  }
+  if (n <= 10000n && notZero) {
+    return 3;
+  }
+  if (p === void 0 && n > 10n ** 21n) {
+    return 2;
+  }
+  if (p === void 0 && n > 10n ** 24n) {
+    return 0;
+  }
+  return p;
+};
+var limitNum = (n, d = 18) => {
+  let limited = n <= 2n ? 0n : n;
+  if (d <= 6) {
+    return limited * 10n ** BigInt(6 - d);
+  } else {
+    return limited / 10n ** BigInt(d - 6);
+  }
+};
+function toHumanFormat(num, precision = 2) {
+  if (num >= BigInt(1e15)) {
+    return `${formatBn4dig(num / BigInt(1e9), precision)}Bn`;
+  }
+  if (num >= BigInt(1e12)) {
+    return `${formatBn4dig(num / BigInt(1e6), precision)}M`;
+  }
+  if (num >= BigInt(1e9)) {
+    return `${formatBn4dig(num / BigInt(1e3), precision)}K`;
+  }
+  return formatBn4dig(num, precision);
+}
+function formatBn4dig(num, precision = 2) {
+  if (precision > 6) {
+    throw new Error("Precision is too high, try <= 6");
+  }
+  const numStr = num.toString();
+  if (numStr.length <= 6) {
+    const completed = "0".repeat(6 - numStr.length) + numStr;
+    return `0.${completed.slice(0, precision)}`;
+  }
+  return `${numStr.slice(0, numStr.length - 6)}.${numStr.slice(
+    numStr.length - 6,
+    numStr.length - 6 + precision
+  )}`;
+}
+function fmtBinaryMask(mask) {
+  return mask.toString(2).padStart(64, "0");
+}
+function numberWithCommas(x) {
+  return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+function formatDuration(seconds, raw = true) {
+  const now = Math.floor(Date.now() / 1e3) * 1e3;
+  const start = new Date(now);
+  const end = new Date(now + seconds * 1e3);
+  const duration = dateFns.intervalToDuration({ start, end });
+  return `${dateFns.formatDuration(duration)}` + (raw ? `[${seconds.toString()}]` : "");
+}
+function formatNumberToString_(value) {
+  return value.toLocaleString("en-US", { minimumIntegerDigits: 1, useGrouping: true }).replaceAll(",", "_");
+}
+
+// src/base/AddressLabeller.ts
+var AddressLabeller = class {
+  #labels = new AddressMap();
+  set(address, label) {
+    if (address === NOT_DEPLOYED) {
+      return;
+    }
+    if (typeof label === "string") {
+      this.#labels.upsert(address, label);
+    } else {
+      this.#labels.upsert(address, label(this.#labels.get(address)));
+    }
+  }
+  get(address) {
+    const label = this.#labels.get(address);
+    return label ? `${address} [${label}]` : address;
+  }
+  get all() {
+    return this.#labels.asRecord();
+  }
+};
 
 // src/base/SDKConstruct.ts
 var SDKConstruct = class {
@@ -12442,9 +12933,6 @@ var Provider = class {
   chain;
   networkType;
   publicClient;
-  /**
-   * Note: use interface here to hide implementation that uses sdk-gov
-   */
   addressLabels;
   constructor(opts) {
     const { chainId, networkType, rpcURL, timeout = 12e4 } = opts;
@@ -12462,6 +12950,504 @@ var Provider = class {
     this.addressLabels = new AddressLabeller();
   }
 };
+
+// src/utils/viem/detectNetwork.ts
+async function detectNetwork(client) {
+  for (const chain of SUPPORTED_CHAINS) {
+    try {
+      await client.readContract({
+        abi: ierc20MetadataAbi,
+        address: USDC[chain],
+        functionName: "symbol"
+      });
+      return chain;
+    } catch {
+    }
+  }
+  throw new Error("Unsupported network");
+}
+
+// src/utils/viem/createAnvilClient.ts
+function createAnvilClient({
+  chain,
+  transport
+}) {
+  return viem.createTestClient(
+    {
+      chain,
+      mode: "anvil",
+      transport,
+      cacheTime: 0
+    }
+  ).extend(viem.publicActions).extend(viem.walletActions).extend((client) => ({
+    isAnvil: () => isAnvil(client),
+    detectNetwork: () => detectNetwork(client)
+  }));
+}
+async function isAnvil(client) {
+  try {
+    const resp = await client.request({
+      method: "anvil_nodeInfo",
+      params: []
+    });
+    return !!resp.currentBlockNumber;
+  } catch {
+    return false;
+  }
+}
+async function simulateMulticall(client, parameters) {
+  const {
+    allowFailure = true,
+    batchSize: batchSize_,
+    blockNumber,
+    blockTag,
+    multicallAddress: multicallAddress_,
+    stateOverride,
+    gas
+  } = parameters;
+  const contracts = parameters.contracts;
+  const batchSize = batchSize_ ?? (typeof client.batch?.multicall === "object" && client.batch.multicall.batchSize || 1024);
+  let multicallAddress = multicallAddress_;
+  if (!multicallAddress) {
+    if (!client.chain)
+      throw new Error(
+        "client chain not configured. multicallAddress is required."
+      );
+    multicallAddress = viem.getChainContractAddress({
+      blockNumber,
+      chain: client.chain,
+      contract: "multicall3"
+    });
+  }
+  const chunkedCalls = [[]];
+  let currentChunk = 0;
+  let currentChunkSize = 0;
+  for (const contract of contracts) {
+    const { abi: abi2, address, args, functionName } = contract;
+    try {
+      const callData = viem.encodeFunctionData({ abi: abi2, args, functionName });
+      currentChunkSize += (callData.length - 2) / 2;
+      if (
+        // Check if batching is enabled.
+        batchSize > 0 && // Check if the current size of the batch exceeds the size limit.
+        currentChunkSize > batchSize && // Check if the current chunk is not already empty.
+        chunkedCalls[currentChunk].length > 0
+      ) {
+        currentChunk++;
+        currentChunkSize = (callData.length - 2) / 2;
+        chunkedCalls[currentChunk] = [];
+      }
+      chunkedCalls[currentChunk] = [
+        ...chunkedCalls[currentChunk],
+        {
+          allowFailure: true,
+          callData,
+          target: address
+        }
+      ];
+    } catch (err) {
+      const error = viem.getContractError(err, {
+        abi: abi2,
+        address,
+        args,
+        docsPath: "/docs/contract/multicall",
+        functionName
+      });
+      if (!allowFailure) throw error;
+      chunkedCalls[currentChunk] = [
+        ...chunkedCalls[currentChunk],
+        {
+          allowFailure: true,
+          callData: "0x",
+          target: address
+        }
+      ];
+    }
+  }
+  const aggregate3Results = await Promise.allSettled(
+    chunkedCalls.map(
+      (calls) => utils.getAction(
+        client,
+        actions.simulateContract,
+        "simulateContract"
+      )({
+        abi: viem.multicall3Abi,
+        address: multicallAddress,
+        args: [calls],
+        blockNumber,
+        blockTag,
+        // does not infer well that either blockNumber or blockTag must be present
+        functionName: "aggregate3",
+        stateOverride,
+        gas
+      })
+    )
+  );
+  const results = [];
+  for (let i = 0; i < aggregate3Results.length; i++) {
+    const result = aggregate3Results[i];
+    if (result.status === "rejected") {
+      if (!allowFailure) {
+        throw result.reason;
+      }
+      for (const _i of chunkedCalls[i]) {
+        results.push({
+          status: "failure",
+          error: result.reason,
+          result: void 0
+        });
+      }
+      continue;
+    }
+    const aggregate3Result = result.value.result;
+    for (let j = 0; j < aggregate3Result.length; j++) {
+      const { returnData, success } = aggregate3Result[j];
+      const { callData } = chunkedCalls[i][j];
+      const { abi: abi2, address, functionName, args } = contracts[results.length];
+      try {
+        if (callData === "0x") throw new viem.AbiDecodingZeroDataError();
+        if (!success) throw new viem.RawContractError({ data: returnData });
+        const result2 = viem.decodeFunctionResult({
+          abi: abi2,
+          args,
+          data: returnData,
+          functionName
+        });
+        results.push(allowFailure ? { result: result2, status: "success" } : result2);
+      } catch (err) {
+        const error = viem.getContractError(err, {
+          abi: abi2,
+          address,
+          args,
+          docsPath: "/docs/contract/multicall",
+          functionName
+        });
+        if (!allowFailure) throw error;
+        results.push({ error, result: void 0, status: "failure" });
+      }
+    }
+  }
+  if (results.length !== contracts.length)
+    throw new viem.BaseError("multicall results mismatch");
+  return results;
+}
+
+// src/accounts/CreditAccountsService.ts
+var CreditAccountsService = class extends SDKConstruct {
+  #compressor;
+  #wallet;
+  constructor(sdk, wallet) {
+    super(sdk);
+    this.#compressor = sdk.addressProvider.getLatestVersion(
+      AP_CREDIT_ACCOUNT_COMPRESSOR
+    );
+    this.#wallet = wallet;
+  }
+  /**
+   * Returns single credit account data, or undefined if it's not found
+   * Performs all necessary price feed updates under the hood
+   * @param account
+   * @returns
+   */
+  async getCreditAccountData(account) {
+    let raw;
+    try {
+      raw = await this.provider.publicClient.readContract({
+        abi: iCreditAccountCompressorAbi,
+        address: this.#compressor,
+        functionName: "getCreditAccountData",
+        args: [account]
+      });
+    } catch (e) {
+      return void 0;
+    }
+    if (raw.success) {
+      return raw;
+    }
+    const { txs: priceUpdateTxs, timestamp: _ } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs();
+    const resp = await simulateMulticall(this.#wallet, {
+      contracts: [
+        ...priceUpdateTxs.map(rawTxToMulticallPriceUpdate),
+        {
+          abi: iCreditAccountCompressorAbi,
+          address: this.#compressor,
+          functionName: "getCreditAccountData",
+          args: [account]
+        }
+      ],
+      allowFailure: false,
+      gas: 550000000n,
+      batchSize: 0
+      // we cannot have price updates and compressor request in different batches
+    });
+    const cad = resp.pop();
+    return cad;
+  }
+  /**
+   * Methods to get all credit accounts with some optional filtering
+   * Performs all necessary price feed updates under the hood
+   *
+   * TODO: do we want to expose pagination?
+   * TODO: do we want to expose "reverting"?
+   * TODO: do we want to expose MarketFilter in any way? If so, we need to check that the MarketFilter is compatibled with attached markets?
+   * @param args
+   * @returns
+   */
+  async getCreditAccounts(args) {
+    const {
+      creditManager,
+      includeZeroDebt = false,
+      maxHealthFactor = 65535,
+      // TODO: this will change to bigint
+      minHealthFactor = 0,
+      owner = ADDRESS_0X0
+    } = args ?? {};
+    const arg0 = creditManager ?? {
+      curators: [],
+      pools: this.pools,
+      underlying: ADDRESS_0X0
+    };
+    const caFilter = {
+      owner,
+      includeZeroDebt,
+      minHealthFactor,
+      maxHealthFactor
+    };
+    const { txs: priceUpdateTxs, timestamp: _ } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs();
+    const allCAs = [];
+    for (const reverting of [false, true]) {
+      let offset = 0n;
+      do {
+        const [accounts, newOffset] = await this.#getCreditAccounts({
+          priceUpdateTxs,
+          args: [arg0, { ...caFilter, reverting }, offset]
+        });
+        allCAs.push(...accounts);
+        offset = newOffset;
+      } while (offset !== 0n);
+    }
+    return allCAs;
+  }
+  /**
+   * Generates transaction to liquidate credit account
+   * @param account
+   * @param to Address to transfer underlying left after liquidation
+   * @param slippage
+   * @returns
+   */
+  async fullyLiquidate(account, to, slippage = 50n) {
+    const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
+    const market = this.sdk.marketRegister.findByCreditManager(
+      account.creditManager
+    );
+    const preview = await this.sdk.router.findBestClosePath(
+      account,
+      cm.creditManager,
+      slippage
+    );
+    const priceUpdates = await this.#getUpdateForAccounts(account);
+    const priceUpdateCalls = market.priceOracle.onDemandPriceUpdates(
+      cm.creditFacade.address,
+      priceUpdates
+    );
+    return cm.creditFacade.createRawTx({
+      functionName: "liquidateCreditAccount",
+      args: [
+        account.creditAccount,
+        to,
+        [...priceUpdateCalls, ...preview.calls]
+      ]
+    });
+  }
+  /**
+   * Closes credit account or sets debt to zero (but keep account)
+   * @param operation
+   * @param ca
+   * @param assetsToKeep Tokens to withdraw from credit account
+   * @param to Address to withdraw underlying to
+   * @param slippage
+   * @returns
+   */
+  async closeCreditAccount(operation, ca, assetsToKeep, to, slippage = 50n) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const calls = await this.#prepareCloseCreditAccount(
+      ca,
+      cm,
+      assetsToKeep,
+      to,
+      slippage
+    );
+    return cm.creditFacade.createRawTx({
+      functionName: operation === "close" ? "closeCreditAccount" : "multicall",
+      args: [ca.creditAccount, calls]
+    });
+  }
+  /**
+   * Internal wrapper for CreditAccountCompressor.getCreditAccounts + price updates wrapped into multicall
+   * @param param0
+   * @returns
+   */
+  async #getCreditAccounts({
+    args,
+    priceUpdateTxs
+  }) {
+    if (priceUpdateTxs?.length) {
+      const resp = await simulateMulticall(this.#wallet, {
+        contracts: [
+          ...priceUpdateTxs.map(rawTxToMulticallPriceUpdate),
+          {
+            abi: iCreditAccountCompressorAbi,
+            address: this.#compressor,
+            functionName: "getCreditAccounts",
+            args
+          }
+        ],
+        allowFailure: false,
+        gas: 550000000n,
+        batchSize: 0
+        // we cannot have price updates and compressor request in different batches
+      });
+      const getCreditAccountsResp = resp.pop();
+      return getCreditAccountsResp;
+    }
+    return this.provider.publicClient.readContract({
+      abi: iCreditAccountCompressorAbi,
+      address: this.#compressor,
+      functionName: "getCreditAccounts",
+      args
+    });
+  }
+  /**
+   * Returns raw txs that are needed to update all price feeds so that all credit accounts (possibly from different markets) compute
+   * @param accounts
+   * @returns
+   */
+  async #getUpdateForAccounts(...accounts) {
+    const tokensByPool = /* @__PURE__ */ new Map();
+    const oracleByPool = /* @__PURE__ */ new Map();
+    for (const acc of accounts) {
+      const market = this.sdk.marketRegister.findByCreditManager(
+        acc.creditManager
+      );
+      const pool = market.state.pool.pool.address;
+      oracleByPool.set(pool, market.priceOracle);
+      for (const t of acc.tokens) {
+        if (t.balance > 10n) {
+          const tokens = tokensByPool.get(pool) ?? /* @__PURE__ */ new Set();
+          tokens.add(t.token);
+          tokensByPool.set(pool, tokens);
+        }
+      }
+    }
+    const priceFeeds = [];
+    for (const [pool, priceFeedFactory] of oracleByPool.entries()) {
+      const tokens = Array.from(tokensByPool.get(pool) ?? []);
+      priceFeeds.push(...priceFeedFactory.priceFeedsForTokens(tokens));
+    }
+    return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(priceFeeds);
+  }
+  async #prepareCloseCreditAccount(ca, cm, assetsToKeep, to, slippage = 50n) {
+    const market = this.sdk.marketRegister.findByCreditManager(
+      ca.creditManager
+    );
+    const closePath = await this.sdk.router.findBestClosePath(
+      ca,
+      cm.creditManager,
+      slippage
+    );
+    const priceUpdates = await this.#getUpdateForAccounts(ca);
+    const priceUpdateCalls = market.priceOracle.onDemandPriceUpdates(
+      cm.creditFacade.address,
+      priceUpdates
+    );
+    return [
+      ...priceUpdateCalls,
+      ...closePath.calls,
+      ...this.#prepareDisableQuotas(ca),
+      ...this.#prepareDecreaseDebt(ca),
+      ...this.#prepareDisableTokens(ca),
+      ...assetsToKeep.map(
+        (t) => this.#prepareWithdrawToken(ca, t, MAX_UINT256, to)
+      )
+    ];
+  }
+  #prepareDisableQuotas(ca) {
+    const calls = [];
+    for (const { token, quota } of ca.tokens) {
+      if (quota > 0n) {
+        calls.push({
+          target: ca.creditFacade,
+          callData: viem.encodeFunctionData({
+            abi: iCreditFacadeV3MulticallAbi,
+            functionName: "updateQuota",
+            args: [token, MIN_INT96, 0n]
+          })
+        });
+      }
+    }
+    return calls;
+  }
+  #prepareDecreaseDebt(ca) {
+    if (ca.totalDebtUSD > 0n) {
+      return [
+        {
+          target: ca.creditFacade,
+          callData: viem.encodeFunctionData({
+            abi: iCreditFacadeV3MulticallAbi,
+            functionName: "decreaseDebt",
+            args: [MAX_UINT256]
+          })
+        }
+      ];
+    }
+    return [];
+  }
+  #prepareDisableTokens(ca) {
+    const calls = [];
+    for (const t of ca.tokens) {
+      if (t.token !== ca.underlying && (t.mask & ca.enabledTokensMask) !== 0n && t.quota === 0n) {
+        calls.push({
+          target: ca.creditFacade,
+          callData: viem.encodeFunctionData({
+            abi: iCreditFacadeV3MulticallAbi,
+            functionName: "disableToken",
+            args: [t.token]
+          })
+        });
+      }
+    }
+    return calls;
+  }
+  #prepareWithdrawToken(ca, token, amount, to) {
+    return {
+      target: ca.creditFacade,
+      callData: viem.encodeFunctionData({
+        abi: iCreditFacadeV3MulticallAbi,
+        functionName: "withdrawCollateral",
+        args: [token, amount, to]
+      })
+    };
+  }
+  /**
+   * Returns addresses of pools of attached markets
+   */
+  get pools() {
+    return this.sdk.marketRegister.poolState.map((p) => p.pool.address);
+  }
+};
+function rawTxToMulticallPriceUpdate(tx) {
+  const { to, callData } = tx;
+  const { args, functionName } = viem.decodeFunctionData({
+    abi: iUpdatablePriceFeedAbi,
+    data: callData
+  });
+  return {
+    abi: iUpdatablePriceFeedAbi,
+    address: to,
+    functionName,
+    args
+  };
+}
 var AddressProviderContractV3_1 = class extends BaseContract {
   #addresses = {};
   versions = {};
@@ -12576,7 +13562,7 @@ var BotListContract = class extends BaseContract {
         return [
           this.addressLabels.get(bot),
           this.addressLabels.get(creditManager),
-          sdkGov.botPermissionsToString(permissions)
+          botPermissionsToString(permissions)
         ];
       }
       default:
@@ -12607,7 +13593,7 @@ var BotListContract = class extends BaseContract {
         break;
       case "SetBotSpecialPermissions":
         this.logger?.debug(
-          `Bot ${parsedLog.args.bot} has been given permissions ${sdkGov.botPermissionsToString(
+          `Bot ${parsedLog.args.bot} has been given permissions ${botPermissionsToString(
             parsedLog.args.permissions
           )} for credit manager ${parsedLog.args.creditManager}`
         );
@@ -12647,16 +13633,18 @@ var GearStakingContract = class extends BaseContract {
     };
   }
 };
+
+// src/market/CreditConfiguratorContract.ts
 var CreditConfiguratorContract = class extends BaseContract {
   adapters = [];
   emergencyLiquidators = [];
-  constructor(sdk, { creditConfigurator, creditManager }, emergencyLiquidators2) {
+  constructor(sdk, { creditConfigurator, creditManager }, emergencyLiquidators) {
     super(sdk, {
       ...creditConfigurator.baseParams,
       name: `CreditConfigurator(${creditManager.name})`,
       abi: creditConfiguratorV3Abi
     });
-    this.emergencyLiquidators = [...emergencyLiquidators2];
+    this.emergencyLiquidators = [...emergencyLiquidators];
   }
   get state() {
     return {
@@ -12669,7 +13657,7 @@ var CreditConfiguratorContract = class extends BaseContract {
       case "addCollateralToken":
       case "setLiquidationThreshold": {
         const [token, lt] = params.args;
-        return [this.addressLabels.get(token), sdkGov.percentFmt(lt)];
+        return [this.addressLabels.get(token), percentFmt(lt)];
       }
       case "setExpirationDate": {
         const [expirationDate] = params.args;
@@ -12684,11 +13672,11 @@ var CreditConfiguratorContract = class extends BaseContract {
           liquidationPremiumExpired
         ] = params.args;
         return [
-          sdkGov.percentFmt(feeInterest),
-          sdkGov.percentFmt(feeLiquidation),
-          sdkGov.percentFmt(liquidationPremium),
-          sdkGov.percentFmt(feeLiquidationExpired),
-          sdkGov.percentFmt(liquidationPremiumExpired)
+          percentFmt(feeInterest),
+          percentFmt(feeLiquidation),
+          percentFmt(liquidationPremium),
+          percentFmt(feeLiquidationExpired),
+          percentFmt(liquidationPremiumExpired)
         ];
       }
       // case "setMinDebtLimit":
@@ -12704,9 +13692,9 @@ var CreditConfiguratorContract = class extends BaseContract {
         const [token, liquidationThresholdFinal, rampStart, rampDuration] = params.args;
         return [
           this.addressLabels.get(token),
-          sdkGov.percentFmt(liquidationThresholdFinal),
+          percentFmt(liquidationThresholdFinal),
           `${rampStart}`,
-          sdkGov.formatDuration(rampDuration)
+          formatDuration(rampDuration)
         ];
       }
       default:
@@ -12714,6 +13702,8 @@ var CreditConfiguratorContract = class extends BaseContract {
     }
   }
 };
+
+// src/market/CreditFacadeContract.ts
 var CreditFacadeContract = class extends BaseContract {
   state;
   constructor(sdk, { creditFacade, creditManager }) {
@@ -12780,7 +13770,7 @@ var CreditFacadeContract = class extends BaseContract {
         return [
           this.addressLabels.get(creditAccount),
           this.addressLabels.get(bot),
-          sdkGov.fmtBinaryMask(permissions)
+          fmtBinaryMask(permissions)
         ];
       }
       default:
@@ -12792,7 +13782,7 @@ var CreditFacadeContract = class extends BaseContract {
 // src/market/CreditManagerContract.ts
 var CreditManagerContract = class extends BaseContract {
   state;
-  constructor(sdk, { creditManager, creditFacade }, pool) {
+  constructor(sdk, { creditManager, creditFacade, adapters }, pool) {
     super(sdk, {
       ...creditManager.baseParams,
       name: `CreditManagerV3(${creditManager.name})`,
@@ -12817,14 +13807,9 @@ var CreditManagerContract = class extends BaseContract {
       feeLiquidationExpired: creditManager.feeLiquidationExpired,
       liquidationDiscountExpired: creditManager.liquidationDiscountExpired,
       quotedTokensMask: 0n,
-      contractsToAdapters: {},
-      // cmd.adapters.reduce(
-      //   (acc, adapter) => {
-      //     acc[adapter.targetContract as Address] = adapter.adapter as Address;
-      //     return acc;
-      //   },
-      //   {} as Record<Address, Address>,
-      // ),
+      contractsToAdapters: Object.fromEntries(
+        adapters.map((a) => [a.targetContract, a.baseParams.addr])
+      ),
       creditAccounts: [],
       // [...result[5].result!],
       name: creditManager.name
@@ -12850,7 +13835,7 @@ var CreditFactory = class {
   // TODO:
   // adapterFactory: AdapterFactory;
   constructor(sdk, marketData, index) {
-    const { creditManagers, pool, emergencyLiquidators: emergencyLiquidators2 } = marketData;
+    const { creditManagers, pool, emergencyLiquidators } = marketData;
     const creditManager = creditManagers[index];
     const { name, collateralTokens, liquidationThresholds } = creditManager.creditManager;
     this.name = name;
@@ -12864,7 +13849,7 @@ var CreditFactory = class {
     this.creditConfigurator = new CreditConfiguratorContract(
       sdk,
       creditManager,
-      emergencyLiquidators2
+      emergencyLiquidators
     );
   }
   async tvl() {
@@ -12992,7 +13977,7 @@ var PoolContract = class extends BaseContract {
       ...this.contractData,
       lastBaseInterestUpdate: data.lastBaseInterestUpdate,
       underlying: data.underlying,
-      decimals: sdkGov.decimals[sdkGov.getTokenSymbol(data.underlying)],
+      decimals: sdk.marketRegister.tokensMeta.mustGet(data.underlying).decimals,
       creditManagerDebtParams,
       withdrawFee: Number(data.withdrawFee)
     };
@@ -13019,7 +14004,7 @@ var PoolContract = class extends BaseContract {
       case "deposit": {
         const [amount, onBehalfOf] = params.args;
         return [
-          sdkGov.formatBN(amount, this.state.decimals),
+          formatBN(amount, this.state.decimals),
           this.addressLabels.get(onBehalfOf)
         ];
       }
@@ -13028,6 +14013,8 @@ var PoolContract = class extends BaseContract {
     }
   }
 };
+
+// src/market/PoolQuotaKeeperContract.ts
 var PoolQuotaKeeperContract = class extends BaseContract {
   decimals;
   state;
@@ -13037,7 +14024,9 @@ var PoolQuotaKeeperContract = class extends BaseContract {
       name: `PoolQuotaKeeper(${pool.name})`,
       abi: poolQuotaKeeperV3Abi
     });
-    this.decimals = sdkGov.decimals[sdkGov.getTokenSymbol(pool.underlying)];
+    this.decimals = sdk.marketRegister.tokensMeta.mustGet(
+      pool.underlying
+    ).decimals;
     this.state = {
       ...this.contractData,
       quotas: Object.fromEntries(
@@ -13413,7 +14402,7 @@ var Erc4626PriceFeedContract = class extends AbstractLPPriceFeedContract {
     };
   }
   async getValue() {
-    const decimals4 = await this.sdk.provider.publicClient.readContract({
+    const decimals2 = await this.sdk.provider.publicClient.readContract({
       abi: erc20Abi,
       address: this.lpContract,
       functionName: "decimals"
@@ -13422,7 +14411,7 @@ var Erc4626PriceFeedContract = class extends AbstractLPPriceFeedContract {
       abi: viem.erc4626Abi,
       address: this.lpContract,
       functionName: "convertToAssets",
-      args: [10n ** BigInt(decimals4)]
+      args: [10n ** BigInt(decimals2)]
     });
     return price;
   }
@@ -13976,7 +14965,8 @@ var PriceOracleContract = class extends BaseContract {
   // }
   #labelPriceFeed(address, usage, token) {
     this.sdk.provider.addressLabels.set(address, (label) => {
-      let pricefeedTag = `${sdkGov.getTokenSymbolOrTicker(token)}.${usage}`;
+      const { symbol } = this.sdk.marketRegister.tokensMeta.mustGet(token);
+      let pricefeedTag = `${symbol}.${usage}`;
       if (label) {
         pricefeedTag = `${label}, ${pricefeedTag}`;
       }
@@ -14029,14 +15019,15 @@ var MarketFactory = class {
   creditManagers = [];
   constructor(sdk, marketData) {
     this.riskCurator = marketData.owner;
+    for (const t of marketData.tokens) {
+      sdk.marketRegister.tokensMeta.upsert(t.addr, t);
+      sdk.provider.addressLabels.set(t.addr, t.symbol);
+    }
     this.poolFactory = new PoolFactory(sdk, marketData);
     for (let i = 0; i < marketData.creditManagers.length; i++) {
       this.creditManagers.push(new CreditFactory(sdk, marketData, i));
     }
     this.priceOracle = new PriceOracleContract(sdk, marketData.priceOracleData);
-    for (const t of marketData.tokens) {
-      sdk.provider.addressLabels.set(t.addr, t.symbol);
-    }
   }
   get state() {
     return {
@@ -14197,7 +15188,7 @@ var PathOptionFactory = class _PathOptionFactory {
   }
   static getBalancerPools(balances) {
     const nonZeroBalances = Object.entries(balances).filter(
-      ([, balance]) => sdkGov.toBigInt(balance.balance) > 1
+      ([, balance]) => balance.balance > 1
     );
     const balancerPools = nonZeroBalances.map(([token]) => sdkGov.getTokenSymbol(token)).filter((symbol) => sdkGov.isBalancerLPToken(symbol));
     const balancerAuraTokens = Object.entries(aura.auraTokens).filter(([, data]) => sdkGov.isBalancerLPToken(data.underlying)).map(([token]) => token);
@@ -14420,8 +15411,8 @@ var RouterV3Contract = class extends BaseContract {
       const token = t;
       const isEnabled = (mask & ca.enabledTokensMask) !== 0n;
       expectedBalances[token] = { token, balance };
-      const decimals4 = this.sdk.marketRegister.tokensMeta.mustGet(token).decimals;
-      const minBalance = 10n ** BigInt(Math.max(8, decimals4) - 8);
+      const decimals2 = this.sdk.marketRegister.tokensMeta.mustGet(token).decimals;
+      const minBalance = 10n ** BigInt(Math.max(8, decimals2) - 8);
       if (balance < minBalance || !isEnabled) {
         leftoverBalances[token] = { token, balance };
       }
@@ -14459,49 +15450,6 @@ function compareRouterResults(a, b) {
 function assetsMap(assets) {
   return new AddressMap(assets.map(({ token, balance }) => [token, balance]));
 }
-async function detectNetwork(client) {
-  for (const chain of sdkGov.supportedChains) {
-    try {
-      await client.readContract({
-        abi: ierc20MetadataAbi,
-        address: sdkGov.tokenDataByNetwork[chain].USDC,
-        functionName: "symbol"
-      });
-      return chain;
-    } catch {
-    }
-  }
-  throw new Error("Unsupported network");
-}
-
-// src/utils/viem/createAnvilClient.ts
-function createAnvilClient({
-  chain,
-  transport
-}) {
-  return viem.createTestClient(
-    {
-      chain,
-      mode: "anvil",
-      transport,
-      cacheTime: 0
-    }
-  ).extend(viem.publicActions).extend(viem.walletActions).extend((client) => ({
-    isAnvil: () => isAnvil(client),
-    detectNetwork: () => detectNetwork(client)
-  }));
-}
-async function isAnvil(client) {
-  try {
-    const resp = await client.request({
-      method: "anvil_nodeInfo",
-      params: []
-    });
-    return !!resp.currentBlockNumber;
-  } catch {
-    return false;
-  }
-}
 
 // src/GearboxSDK.ts
 var GearboxSDK = class _GearboxSDK extends eventemitter3.EventEmitter {
@@ -14591,7 +15539,9 @@ var GearboxSDK = class _GearboxSDK extends eventemitter3.EventEmitter {
       gearStakingAddress
     );
     this.#marketRegister = new MarketRegister(this);
-    await this.#marketRegister.loadMarkets([sdkGov.TIMELOCK.Mainnet]);
+    await this.#marketRegister.loadMarkets([
+      TIMELOCK[this.provider.networkType]
+    ]);
     try {
       const router = this.#addressProvider.getLatestVersion(AP_ROUTER);
       this.#router = new RouterV3Contract(this, router);
@@ -14652,7 +15602,7 @@ var GearboxSDK = class _GearboxSDK extends eventemitter3.EventEmitter {
   async tvl() {
     const { tvl, tvlUSD } = await this.marketRegister.tvl();
     this.logger?.info(tvl);
-    this.logger?.info(`Total TVL: ${sdkGov.formatBN(tvlUSD, 8)}`);
+    this.logger?.info(`Total TVL: ${formatBN(tvlUSD, 8)}`);
   }
   async syncState(toBlock, timestamp) {
     if (toBlock <= this.currentBlock) {
@@ -14719,7 +15669,7 @@ var GearboxSDK = class _GearboxSDK extends eventemitter3.EventEmitter {
     return this.#router;
   }
 };
-function convertCreditFacadeStateToHuman(state, decimals4, labelAddress, _raw = true) {
+function convertCreditFacadeStateToHuman(state, decimals2, labelAddress, _raw = true) {
   return {
     ...convertBaseContractState(state, labelAddress),
     maxQuotaMultiplier: state.maxQuotaMultiplier,
@@ -14729,11 +15679,11 @@ function convertCreditFacadeStateToHuman(state, decimals4, labelAddress, _raw =
     expirationDate: state.expirationDate,
     maxDebtPerBlockMultiplier: state.maxDebtPerBlockMultiplier,
     botList: labelAddress(state.botList),
-    minDebt: sdkGov.formatBNvalue(state.minDebt, decimals4),
-    maxDebt: sdkGov.formatBNvalue(state.maxDebt, decimals4),
-    currentCumulativeLoss: sdkGov.formatBNvalue(state.currentCumulativeLoss, decimals4),
-    maxCumulativeLoss: sdkGov.formatBNvalue(state.maxCumulativeLoss, decimals4),
-    forbiddenTokenMask: sdkGov.fmtBinaryMask(state.forbiddenTokenMask),
+    minDebt: formatBNvalue(state.minDebt, decimals2),
+    maxDebt: formatBNvalue(state.maxDebt, decimals2),
+    currentCumulativeLoss: formatBNvalue(state.currentCumulativeLoss, decimals2),
+    maxCumulativeLoss: formatBNvalue(state.maxCumulativeLoss, decimals2),
+    forbiddenTokenMask: fmtBinaryMask(state.forbiddenTokenMask),
     isPaused: state.isPaused
   };
 }
@@ -14751,18 +15701,18 @@ function convertCreditManagerStateToHuman(state, labelAddress, raw = true) {
     collateralTokens: Object.fromEntries(
       Object.entries(state.collateralTokens).map(([k, v]) => [
         labelAddress(k),
-        sdkGov.percentFmt(v, raw)
+        percentFmt(v, raw)
       ])
     ),
-    feeInterest: sdkGov.percentFmt(state.feeInterest, raw),
-    feeLiquidation: sdkGov.percentFmt(state.feeLiquidation, raw),
-    liquidationDiscount: sdkGov.percentFmt(state.liquidationDiscount, raw),
-    feeLiquidationExpired: sdkGov.percentFmt(state.feeLiquidationExpired, raw),
-    liquidationDiscountExpired: sdkGov.percentFmt(
+    feeInterest: percentFmt(state.feeInterest, raw),
+    feeLiquidation: percentFmt(state.feeLiquidation, raw),
+    liquidationDiscount: percentFmt(state.liquidationDiscount, raw),
+    feeLiquidationExpired: percentFmt(state.feeLiquidationExpired, raw),
+    liquidationDiscountExpired: percentFmt(
       state.liquidationDiscountExpired,
       raw
     ),
-    quotedTokensMask: sdkGov.fmtBinaryMask(state.quotedTokensMask),
+    quotedTokensMask: fmtBinaryMask(state.quotedTokensMask),
     contractsToAdapters: Object.fromEntries(
       Object.entries(state.contractsToAdapters).map(([k, v]) => [
         labelAddress(k),
@@ -14796,6 +15746,8 @@ function convertCreditFactoryStateToHuman(state, labelAddress, _raw = true) {
     )
   };
 }
+
+// src/state/poolStateHuman.ts
 function convertPoolStateToHuman(state, labelAddress, raw = true) {
   return {
     ...convertBaseContractState(state, labelAddress),
@@ -14803,27 +15755,27 @@ function convertPoolStateToHuman(state, labelAddress, raw = true) {
     symbol: state.symbol,
     name: state.name,
     decimals: state.decimals,
-    availableLiquidity: sdkGov.formatBNvalue(
+    availableLiquidity: formatBNvalue(
       state.availableLiquidity,
       state.decimals,
       2,
       raw
     ),
-    expectedLiquidity: sdkGov.formatBNvalue(
+    expectedLiquidity: formatBNvalue(
       state.expectedLiquidity,
       state.decimals,
       2,
       raw
     ),
-    totalBorrowed: sdkGov.formatBNvalue(state.totalBorrowed, state.decimals, 2, raw),
-    totalDebtLimit: sdkGov.formatBNvalue(state.totalDebtLimit, state.decimals, 2, raw),
+    totalBorrowed: formatBNvalue(state.totalBorrowed, state.decimals, 2, raw),
+    totalDebtLimit: formatBNvalue(state.totalDebtLimit, state.decimals, 2, raw),
     creditManagerDebtParams: Object.fromEntries(
       Object.entries(state.creditManagerDebtParams).map(([cm, params]) => [
         labelAddress(cm),
         {
-          borrowed: sdkGov.formatBNvalue(params.borrowed, state.decimals, 2, raw),
-          limit: sdkGov.formatBNvalue(params.limit, state.decimals, 2, raw),
-          availableToBorrow: sdkGov.formatBNvalue(
+          borrowed: formatBNvalue(params.borrowed, state.decimals, 2, raw),
+          limit: formatBNvalue(params.limit, state.decimals, 2, raw),
+          availableToBorrow: formatBNvalue(
             params.availableToBorrow,
             state.decimals,
             2,
@@ -14832,28 +15784,28 @@ function convertPoolStateToHuman(state, labelAddress, raw = true) {
         }
       ])
     ),
-    totalAssets: sdkGov.formatBNvalue(state.totalAssets, state.decimals, 2, raw),
-    totalSupply: sdkGov.formatBNvalue(state.totalSupply, state.decimals, 2, raw),
-    supplyRate: `${sdkGov.formatBNvalue(state.supplyRate, 25, 2, raw)}%`,
-    baseInterestIndex: `${sdkGov.formatBNvalue(state.totalSupply, 25, 2, raw)}%`,
-    baseInterestRate: `${sdkGov.formatBNvalue(state.totalSupply, 25, 2, raw)}%`,
-    withdrawFee: sdkGov.percentFmt(state.withdrawFee),
+    totalAssets: formatBNvalue(state.totalAssets, state.decimals, 2, raw),
+    totalSupply: formatBNvalue(state.totalSupply, state.decimals, 2, raw),
+    supplyRate: `${formatBNvalue(state.supplyRate, 25, 2, raw)}%`,
+    baseInterestIndex: `${formatBNvalue(state.totalSupply, 25, 2, raw)}%`,
+    baseInterestRate: `${formatBNvalue(state.totalSupply, 25, 2, raw)}%`,
+    withdrawFee: percentFmt(state.withdrawFee),
     lastBaseInterestUpdate: state.lastBaseInterestUpdate.toString(),
     baseInterestIndexLU: state.lastBaseInterestUpdate.toString(),
     isPaused: state.isPaused
   };
 }
-function convertPoolQuotaKeeperStateToHuman(state, decimals4, labelAddress, raw = true) {
+function convertPoolQuotaKeeperStateToHuman(state, decimals2, labelAddress, raw = true) {
   return {
     ...convertBaseContractState(state, labelAddress),
     quotas: Object.entries(state.quotas).reduce(
       (acc, [address, params]) => ({
         ...acc,
         [address]: {
-          rate: sdkGov.percentFmt(params.rate, raw),
-          quotaIncreaseFee: sdkGov.percentFmt(params.quotaIncreaseFee, raw),
-          totalQuoted: sdkGov.formatBNvalue(params.totalQuoted, decimals4, 2, raw),
-          limit: sdkGov.formatBNvalue(params.limit, decimals4, 2, raw),
+          rate: percentFmt(params.rate, raw),
+          quotaIncreaseFee: percentFmt(params.quotaIncreaseFee, raw),
+          totalQuoted: formatBNvalue(params.totalQuoted, decimals2, 2, raw),
+          limit: formatBNvalue(params.limit, decimals2, 2, raw),
           isActive: params.isActive
         }
       }),
@@ -14864,12 +15816,12 @@ function convertPoolQuotaKeeperStateToHuman(state, decimals4, labelAddress, raw
 function convertLinearModelStateToHuman(state, labelAddress, raw = true) {
   return {
     ...convertBaseContractState(state, labelAddress),
-    U1: sdkGov.percentFmt(state.U1, raw),
-    U2: sdkGov.percentFmt(state.U2, raw),
-    Rbase: sdkGov.percentFmt(state.Rbase, raw),
-    Rslope1: sdkGov.percentFmt(state.Rslope1, raw),
-    Rslope2: sdkGov.percentFmt(state.Rslope2, raw),
-    Rslope3: sdkGov.percentFmt(state.Rslope3, raw),
+    U1: percentFmt(state.U1, raw),
+    U2: percentFmt(state.U2, raw),
+    Rbase: percentFmt(state.Rbase, raw),
+    Rslope1: percentFmt(state.Rslope1, raw),
+    Rslope2: percentFmt(state.Rslope2, raw),
+    Rslope3: percentFmt(state.Rslope3, raw),
     isBorrowingMoreU2Forbidden: state.isBorrowingMoreU2Forbidden
   };
 }
@@ -14882,11 +15834,11 @@ function convertGaugeStateToHuman(state, labelAddress, raw = true) {
       (acc, [address, params]) => ({
         ...acc,
         [address]: {
-          minRate: sdkGov.percentFmt(params.minRate, raw),
-          maxRate: sdkGov.percentFmt(params.maxRate, raw),
+          minRate: percentFmt(params.minRate, raw),
+          maxRate: percentFmt(params.maxRate, raw),
           totalVotesLpSide: params.totalVotesLpSide / 1e18,
           totalVotesCaSide: params.totalVotesCaSide / 1e18,
-          rate: sdkGov.percentFmt(params.rate, raw)
+          rate: percentFmt(params.rate, raw)
         }
       }),
       {}
@@ -14906,6 +15858,8 @@ function convertPoolFactoryStateToHuman(state, labelAddress, raw = true) {
     gauge: convertGaugeStateToHuman(state.gauge, labelAddress, raw)
   };
 }
+
+// src/state/priceFactoryStateHuman.ts
 function convertPriceOracleStateToHuman(state, labelAddress, _raw = true) {
   return {
     priceOracleV3: {
@@ -14935,7 +15889,7 @@ function convertPriceFeedStateToHuman(state, labelAddress, raw = true) {
         pricefeeds: state.pricefeeds.map(
           (pf) => convertPriceFeedStateToHuman(pf, labelAddress)
         ),
-        stalenessPeriod: sdkGov.formatDuration(state.stalenessPeriod, raw)
+        stalenessPeriod: formatDuration(state.stalenessPeriod, raw)
       };
     }
     case "PF_REDSTONE_ORACLE": {
@@ -14943,7 +15897,7 @@ function convertPriceFeedStateToHuman(state, labelAddress, raw = true) {
         ...state,
         ...convertBaseContractState(state, labelAddress),
         contractType: "PF_REDSTONE_ORACLE",
-        stalenessPeriod: sdkGov.formatDuration(state.stalenessPeriod, raw)
+        stalenessPeriod: formatDuration(state.stalenessPeriod, raw)
       };
     }
     default: {
@@ -14953,7 +15907,7 @@ function convertPriceFeedStateToHuman(state, labelAddress, raw = true) {
         pricefeeds: state.pricefeeds.map(
           (pf) => convertPriceFeedStateToHuman(pf, labelAddress)
         ),
-        stalenessPeriod: sdkGov.formatDuration(state.stalenessPeriod, raw)
+        stalenessPeriod: formatDuration(state.stalenessPeriod, raw)
       };
     }
   }
@@ -15120,9 +16074,11 @@ exports.BalancerStablePriceFeedContract = BalancerStablePriceFeedContract;
 exports.BalancerWeightedPriceFeedContract = BalancerWeightedPriceFeedContract;
 exports.BaseContract = BaseContract;
 exports.BotListContract = BotListContract;
+exports.BotPermissions = BotPermissions;
 exports.BoundedPriceFeedContract = BoundedPriceFeedContract;
 exports.ChainlinkPriceFeedContract = ChainlinkPriceFeedContract;
 exports.CompositePriceFeedContract = CompositePriceFeedContract;
+exports.CreditAccountsService = CreditAccountsService;
 exports.CreditConfiguratorContract = CreditConfiguratorContract;
 exports.CreditFacadeContract = CreditFacadeContract;
 exports.CreditFactory = CreditFactory;
@@ -15135,6 +16091,8 @@ exports.GaugeContract = GaugeContract;
 exports.GearStakingContract = GearStakingContract;
 exports.GearboxSDK = GearboxSDK;
 exports.LinearModelContract = LinearModelContract;
+exports.MAX_UINT256 = MAX_UINT256;
+exports.MIN_INT96 = MIN_INT96;
 exports.MarketFactory = MarketFactory;
 exports.MarketRegister = MarketRegister;
 exports.MellowLRTPriceFeedContract = MellowLRTPriceFeedContract;
@@ -15150,10 +16108,13 @@ exports.Provider = Provider;
 exports.RedstonePriceFeedContract = RedstonePriceFeedContract;
 exports.SDKConstruct = SDKConstruct;
 exports.SUPPORTED_CHAINS = SUPPORTED_CHAINS;
+exports.TIMELOCK = TIMELOCK;
+exports.USDC = USDC;
 exports.VotingContractStatus = VotingContractStatus;
 exports.WstETHPriceFeedContract = WstETHPriceFeedContract;
 exports.YearnPriceFeedContract = YearnPriceFeedContract;
 exports.ZeroPriceFeedContract = ZeroPriceFeedContract;
+exports.botPermissionsToString = botPermissionsToString;
 exports.bytes32ToString = bytes32ToString;
 exports.chains = chains;
 exports.childLogger = childLogger;
@@ -15174,6 +16135,14 @@ exports.convertRouterStateToHuman = convertRouterStateToHuman;
 exports.convertRouterV3StateToHuman = convertRouterV3StateToHuman;
 exports.convertZapperRegisterStateToHuman = convertZapperRegisterStateToHuman;
 exports.createRawTx = createRawTx;
-exports.initLegacyLabels = initLegacyLabels;
+exports.fmtBinaryMask = fmtBinaryMask;
+exports.formatBN = formatBN;
+exports.formatBNvalue = formatBNvalue;
+exports.formatBn4dig = formatBn4dig;
+exports.formatDuration = formatDuration;
+exports.formatNumberToString_ = formatNumberToString_;
 exports.json_parse = json_parse;
 exports.json_stringify = json_stringify;
+exports.numberWithCommas = numberWithCommas;
+exports.percentFmt = percentFmt;
+exports.toHumanFormat = toHumanFormat;