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

package/dist/cjs/index.cjs

@@ -1,266 +1,16 @@
 'use strict';
 
-var sdkGov = require('@gearbox-protocol/sdk-gov');
 var viem = require('viem');
+var sdkGov = require('@gearbox-protocol/sdk-gov');
 var utils = require('viem/utils');
+var actions = require('viem/actions');
 var chains$1 = require('viem/chains');
 var eventemitter3 = require('eventemitter3');
 var evmConnector = require('@redstone-finance/evm-connector');
 var redstoneProtocol = require('redstone-protocol');
 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 = [
@@ -423,9 +173,438 @@ var iAddressProviderV3_1Abi = [
       { name: "addr", internalType: "address", type: "address" },
       { name: "saveVersion", internalType: "bool", type: "bool" }
     ],
-    name: "setAddress",
-    outputs: [],
-    stateMutability: "nonpayable"
+    name: "setAddress",
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "version",
+    outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    anonymous: false,
+    inputs: [
+      {
+        name: "marketConfigurator",
+        internalType: "address",
+        type: "address",
+        indexed: true
+      }
+    ],
+    name: "AddMarketConfigurator"
+  },
+  {
+    type: "event",
+    anonymous: false,
+    inputs: [
+      {
+        name: "marketConfigurator",
+        internalType: "address",
+        type: "address",
+        indexed: true
+      }
+    ],
+    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: "function",
@@ -433,52 +612,6 @@ var iAddressProviderV3_1Abi = [
     name: "version",
     outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
     stateMutability: "view"
-  },
-  {
-    type: "event",
-    anonymous: false,
-    inputs: [
-      {
-        name: "marketConfigurator",
-        internalType: "address",
-        type: "address",
-        indexed: true
-      }
-    ],
-    name: "AddMarketConfigurator"
-  },
-  {
-    type: "event",
-    anonymous: false,
-    inputs: [
-      {
-        name: "marketConfigurator",
-        internalType: "address",
-        type: "address",
-        indexed: true
-      }
-    ],
-    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 iMarketCompressorAbi = [
@@ -12275,7 +12408,262 @@ var routerV3Abi = [
     inputs: [{ name: "", internalType: "address", type: "address" }],
     name: "UnsupportedRouterComponent"
   }
-];
+];
+
+// 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
+};
+
+// 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
+  };
+}
+
+// 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/base/SDKConstruct.ts
 var SDKConstruct = class {
@@ -12425,6 +12813,502 @@ var VotingContractStatus = /* @__PURE__ */ ((VotingContractStatus2) => {
   VotingContractStatus2[VotingContractStatus2["UNVOTE_ONLY"] = 2] = "UNVOTE_ONLY";
   return VotingContractStatus2;
 })(VotingContractStatus || {});
+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;
+  }
+}
+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 SUPPORTED_CHAINS = [
   "Mainnet",
   "Arbitrum",
@@ -12792,7 +13676,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 +13701,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
@@ -14459,49 +15338,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 {
@@ -15123,6 +15959,7 @@ exports.BotListContract = BotListContract;
 exports.BoundedPriceFeedContract = BoundedPriceFeedContract;
 exports.ChainlinkPriceFeedContract = ChainlinkPriceFeedContract;
 exports.CompositePriceFeedContract = CompositePriceFeedContract;
+exports.CreditAccountsService = CreditAccountsService;
 exports.CreditConfiguratorContract = CreditConfiguratorContract;
 exports.CreditFacadeContract = CreditFacadeContract;
 exports.CreditFactory = CreditFactory;
@@ -15135,6 +15972,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;