@gearbox-protocol/sdk 3.0.0-vfour.31 → 3.0.0-vfour.33

package/dist/cjs/sdk/index.cjs

@@ -2067,6 +2067,239 @@ var iMarketCompressorAbi = [
     stateMutability: "view"
   }
 ];
+var iPriceFeedCompressorAbi = [
+  {
+    type: "function",
+    inputs: [],
+    name: "contractType",
+    outputs: [{ name: "", internalType: "bytes32", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "priceOracle", internalType: "address", type: "address" },
+      { name: "tokens", internalType: "address[]", type: "address[]" }
+    ],
+    name: "getPriceFeeds",
+    outputs: [
+      {
+        name: "priceFeedMap",
+        internalType: "struct PriceFeedMapEntry[]",
+        type: "tuple[]",
+        components: [
+          { name: "token", internalType: "address", type: "address" },
+          { name: "reserve", internalType: "bool", type: "bool" },
+          { name: "priceFeed", internalType: "address", type: "address" },
+          { name: "stalenessPeriod", internalType: "uint32", type: "uint32" }
+        ]
+      },
+      {
+        name: "priceFeedTree",
+        internalType: "struct PriceFeedTreeNode[]",
+        type: "tuple[]",
+        components: [
+          {
+            name: "baseParams",
+            internalType: "struct BaseParams",
+            type: "tuple",
+            components: [
+              { name: "addr", internalType: "address", type: "address" },
+              { name: "version", internalType: "uint256", type: "uint256" },
+              {
+                name: "contractType",
+                internalType: "bytes32",
+                type: "bytes32"
+              },
+              {
+                name: "serializedParams",
+                internalType: "bytes",
+                type: "bytes"
+              }
+            ]
+          },
+          { name: "decimals", internalType: "uint8", type: "uint8" },
+          { name: "skipCheck", internalType: "bool", type: "bool" },
+          { name: "updatable", internalType: "bool", type: "bool" },
+          {
+            name: "underlyingFeeds",
+            internalType: "address[]",
+            type: "address[]"
+          },
+          {
+            name: "underlyingStalenessPeriods",
+            internalType: "uint32[]",
+            type: "uint32[]"
+          },
+          {
+            name: "answer",
+            internalType: "struct PriceFeedAnswer",
+            type: "tuple",
+            components: [
+              { name: "price", internalType: "int256", type: "int256" },
+              { name: "updatedAt", internalType: "uint256", type: "uint256" },
+              { name: "success", internalType: "bool", type: "bool" }
+            ]
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [{ name: "priceOracle", internalType: "address", type: "address" }],
+    name: "getPriceFeeds",
+    outputs: [
+      {
+        name: "priceFeedMap",
+        internalType: "struct PriceFeedMapEntry[]",
+        type: "tuple[]",
+        components: [
+          { name: "token", internalType: "address", type: "address" },
+          { name: "reserve", internalType: "bool", type: "bool" },
+          { name: "priceFeed", internalType: "address", type: "address" },
+          { name: "stalenessPeriod", internalType: "uint32", type: "uint32" }
+        ]
+      },
+      {
+        name: "priceFeedTree",
+        internalType: "struct PriceFeedTreeNode[]",
+        type: "tuple[]",
+        components: [
+          {
+            name: "baseParams",
+            internalType: "struct BaseParams",
+            type: "tuple",
+            components: [
+              { name: "addr", internalType: "address", type: "address" },
+              { name: "version", internalType: "uint256", type: "uint256" },
+              {
+                name: "contractType",
+                internalType: "bytes32",
+                type: "bytes32"
+              },
+              {
+                name: "serializedParams",
+                internalType: "bytes",
+                type: "bytes"
+              }
+            ]
+          },
+          { name: "decimals", internalType: "uint8", type: "uint8" },
+          { name: "skipCheck", internalType: "bool", type: "bool" },
+          { name: "updatable", internalType: "bool", type: "bool" },
+          {
+            name: "underlyingFeeds",
+            internalType: "address[]",
+            type: "address[]"
+          },
+          {
+            name: "underlyingStalenessPeriods",
+            internalType: "uint32[]",
+            type: "uint32[]"
+          },
+          {
+            name: "answer",
+            internalType: "struct PriceFeedAnswer",
+            type: "tuple",
+            components: [
+              { name: "price", internalType: "int256", type: "int256" },
+              { name: "updatedAt", internalType: "uint256", type: "uint256" },
+              { name: "success", internalType: "bool", type: "bool" }
+            ]
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [
+      { name: "priceFeeds", internalType: "address[]", type: "address[]" }
+    ],
+    name: "loadPriceFeedTree",
+    outputs: [
+      {
+        name: "priceFeedTree",
+        internalType: "struct PriceFeedTreeNode[]",
+        type: "tuple[]",
+        components: [
+          {
+            name: "baseParams",
+            internalType: "struct BaseParams",
+            type: "tuple",
+            components: [
+              { name: "addr", internalType: "address", type: "address" },
+              { name: "version", internalType: "uint256", type: "uint256" },
+              {
+                name: "contractType",
+                internalType: "bytes32",
+                type: "bytes32"
+              },
+              {
+                name: "serializedParams",
+                internalType: "bytes",
+                type: "bytes"
+              }
+            ]
+          },
+          { name: "decimals", internalType: "uint8", type: "uint8" },
+          { name: "skipCheck", internalType: "bool", type: "bool" },
+          { name: "updatable", internalType: "bool", type: "bool" },
+          {
+            name: "underlyingFeeds",
+            internalType: "address[]",
+            type: "address[]"
+          },
+          {
+            name: "underlyingStalenessPeriods",
+            internalType: "uint32[]",
+            type: "uint32[]"
+          },
+          {
+            name: "answer",
+            internalType: "struct PriceFeedAnswer",
+            type: "tuple",
+            components: [
+              { name: "price", internalType: "int256", type: "int256" },
+              { name: "updatedAt", internalType: "uint256", type: "uint256" },
+              { name: "success", internalType: "bool", type: "bool" }
+            ]
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    inputs: [],
+    name: "version",
+    outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    anonymous: false,
+    inputs: [
+      {
+        name: "contractType",
+        internalType: "bytes32",
+        type: "bytes32",
+        indexed: true
+      },
+      {
+        name: "serializer",
+        internalType: "address",
+        type: "address",
+        indexed: true
+      }
+    ],
+    name: "SetSerializer"
+  }
+];
 
 // src/sdk/abi/oracles.ts
 var bptStablePriceFeedAbi = [
@@ -16745,6 +16978,7 @@ 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_PRICE_FEED_COMPRESSOR = "PRICE_FEED_COMPRESSOR";
 var AP_CREDIT_ACCOUNT_COMPRESSOR = "CREDIT_ACCOUNT_COMPRESSOR";
 var AP_TREASURY = "TREASURY";
 var AP_GEAR_TOKEN = "GEAR_TOKEN";
@@ -17273,748 +17507,24 @@ var VotingContractStatus = /* @__PURE__ */ ((VotingContractStatus2) => {
   VotingContractStatus2[VotingContractStatus2["UNVOTE_ONLY"] = 2] = "UNVOTE_ONLY";
   return VotingContractStatus2;
 })(VotingContractStatus || {});
-var SUPPORTED_CHAINS = [
-  "Mainnet",
-  "Arbitrum",
-  "Optimism",
-  "Base"
-];
-var chains = {
-  Mainnet: chains$1.mainnet,
-  Arbitrum: chains$1.arbitrum,
-  Optimism: chains$1.optimism,
-  Base: chains$1.base
-};
-var Provider = class {
-  account;
-  chainId;
-  chain;
-  networkType;
-  publicClient;
-  addressLabels;
-  transport;
-  constructor(opts) {
-    const {
-      account,
-      chainId,
-      networkType,
-      rpcURLs,
-      timeout = 12e4,
-      retryCount
-    } = opts;
-    this.account = account;
-    this.chainId = chainId;
-    this.networkType = networkType;
-    this.chain = viem.defineChain({
-      ...chains[networkType],
-      id: chainId
-    });
-    const rpcs = rpcURLs.map((url) => viem.http(url, { timeout, retryCount }));
-    this.transport = rpcs.length ? viem.fallback(rpcs) : rpcs[0];
-    this.publicClient = viem.createPublicClient({
-      chain: this.chain,
-      transport: this.transport
+
+// src/sdk/market/CreditConfiguratorContract.ts
+var CreditConfiguratorContract = class extends BaseContract {
+  adapters = [];
+  emergencyLiquidators = [];
+  constructor(sdk, { creditConfigurator, creditManager }, emergencyLiquidators) {
+    super(sdk, {
+      ...creditConfigurator.baseParams,
+      name: `CreditConfigurator(${creditManager.name})`,
+      abi: creditConfiguratorV3Abi
     });
-    this.addressLabels = new AddressLabeller();
+    this.emergencyLiquidators = [...emergencyLiquidators];
   }
-};
-
-// src/sdk/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");
-}
-async function simulateMulticall(client, parameters) {
-  const {
-    account,
-    allowFailure = true,
-    batchSize: batchSize_,
-    blockNumber,
-    blockTag,
-    gas,
-    multicallAddress: multicallAddress_,
-    stateOverride
-  } = 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: abi17, address, args, functionName } = contract;
-    try {
-      const callData = viem.encodeFunctionData({ abi: abi17, 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: abi17,
-        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"
-      )({
-        account,
-        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: abi17, 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: abi17,
-          args,
-          data: returnData,
-          functionName
-        });
-        results.push(allowFailure ? { result: result2, status: "success" } : result2);
-      } catch (err) {
-        const error = viem.getContractError(err, {
-          abi: abi17,
-          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/sdk/accounts/CreditAccountsService.ts
-var CreditAccountsService = class extends SDKConstruct {
-  #compressor;
-  constructor(sdk) {
-    super(sdk);
-    this.#compressor = sdk.addressProvider.getLatestVersion(
-      AP_CREDIT_ACCOUNT_COMPRESSOR
-    );
-  }
-  /**
-   * 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.provider.publicClient, {
-      account: this.provider.account,
-      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 returned credit accounts are sorted by health factor in ascending order
-   */
-  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(
-          [arg0, { ...caFilter, reverting }, offset],
-          priceUpdateTxs
-        );
-        allCAs.push(...accounts);
-        offset = newOffset;
-      } while (offset !== 0n);
-    }
-    return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
-  }
-  /**
-   * 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 preview = await this.sdk.router.findBestClosePath(
-      account,
-      cm.creditManager,
-      slippage
-    );
-    const priceUpdates = await this.getPriceUpdatesForFacade(account);
-    const recipient = to ?? this.sdk.provider.account;
-    if (!recipient) {
-      throw new Error("liquidate account: assets recipient not specied");
-    }
-    return cm.creditFacade.createRawTx({
-      functionName: "liquidateCreditAccount",
-      args: [
-        account.creditAccount,
-        recipient,
-        [...priceUpdates, ...preview.calls]
-      ],
-      description: `fully liquidate ${account.creditAccount}`
-    });
-  }
-  /**
-   * 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 recipient = to ?? this.sdk.provider.account;
-    if (!recipient) {
-      throw new Error("close account: assets recipient not specied");
-    }
-    const calls = await this.#prepareCloseCreditAccount(
-      ca,
-      cm,
-      assetsToKeep,
-      recipient,
-      slippage
-    );
-    return cm.creditFacade.createRawTx({
-      functionName: operation === "close" ? "closeCreditAccount" : "multicall",
-      args: [ca.creditAccount, calls],
-      description: `${operation} account ${ca.creditAccount}`
-    });
-  }
-  /**
-   * Internal wrapper for CreditAccountCompressor.getCreditAccounts + price updates wrapped into multicall
-   * @param args
-   * @param priceUpdateTxs
-   * @returns
-   */
-  async #getCreditAccounts(args, priceUpdateTxs) {
-    if (priceUpdateTxs?.length) {
-      const resp = await simulateMulticall(this.provider.publicClient, {
-        account: this.provider.account,
-        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);
-  }
-  /**
-   * Returns account price updates in a non-encoded format
-   * @param acc
-   * @returns
-   */
-  async getOnDemandPriceUpdates(acc) {
-    const market = this.sdk.marketRegister.findByCreditManager(
-      acc.creditManager
-    );
-    const update = await this.getUpdateForAccounts([acc]);
-    return market.priceOracle.onDemandPriceUpdates(update);
-  }
-  /**
-   * Returns price updates in format that is accepted by various credit facade methods (multicall, close/liquidate, etc...)
-   * @param acc
-   * @returns
-   */
-  async getPriceUpdatesForFacade(acc) {
-    const cm = this.sdk.marketRegister.findCreditManager(acc.creditManager);
-    const updates = await this.getOnDemandPriceUpdates(acc);
-    return updates.map(({ token, reserve, data }) => ({
-      target: cm.creditFacade.address,
-      callData: viem.encodeFunctionData({
-        abi: iCreditFacadeV3MulticallAbi,
-        functionName: "onDemandPriceUpdate",
-        args: [token, reserve, data]
-      })
-    }));
-  }
-  async #prepareCloseCreditAccount(ca, cm, assetsToKeep, to, slippage = 50n) {
-    const closePath = await this.sdk.router.findBestClosePath(
-      ca,
-      cm.creditManager,
-      slippage
-    );
-    const priceUpdates = await this.getPriceUpdatesForFacade(ca);
-    return [
-      ...priceUpdates,
-      ...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 = {};
-  latest = {};
-  constructor(sdk, address) {
-    super(sdk, {
-      addr: address,
-      name: "AddressProviderV3",
-      abi: iAddressProviderV3_1Abi
-    });
-  }
-  parseFunctionParams(params) {
-    switch (params.functionName) {
-      case "setAddress": {
-        if (params.args.length !== 3) {
-          const [key2, saveVersion2] = params.args;
-          return [key2, `${saveVersion2}`];
-        }
-        const [key, value, saveVersion] = params.args;
-        return [viem.bytesToString(viem.toBytes(key)), value, `${saveVersion}`];
-      }
-      default:
-        return void 0;
-    }
-  }
-  setInternalAddress(key, address, version) {
-    if (!this.#addresses[key]) {
-      this.#addresses[key] = {};
-    }
-    this.#addresses[key][version] = address;
-    if (!this.latest[key] || version > this.latest[key]) {
-      this.latest[key] = version;
-    }
-    if (!this.versions[key]) {
-      this.versions[key] = /* @__PURE__ */ new Set();
-    }
-    this.versions[key].add(version);
-  }
-  getAddress(contract, version = NO_VERSION) {
-    if (!this.#addresses[contract]) {
-      throw new Error(`Address ${contract}, version: ${version} not found`);
-    }
-    const result = this.#addresses[contract][version];
-    if (!result) {
-      throw new Error(`Address ${contract}, version: ${version} not found`);
-    }
-    return result;
-  }
-  getLatestVersion(contract) {
-    if (!this.latest[contract]) {
-      throw new Error(`Latest version for ${contract} not found`);
-    }
-    this.logger?.debug(
-      `Latest version found for ${contract} : ${this.latest[contract]}`
-    );
-    return this.getAddress(contract, this.latest[contract]);
-  }
-  async fetchState(toBlock) {
-    const entries = await this.contract.read.getAllSavedContracts({
-      blockNumber: toBlock
-    });
-    entries.forEach((log) => {
-      this.setInternalAddress(log.key, log.value, Number(log.version));
-    });
-    this.version = 310;
-  }
-  get state() {
-    return {
-      ...this.contractData,
-      addresses: this.#addresses
-    };
-  }
-  parseLog(log) {
-    const parsedLog = viem.parseEventLogs({
-      abi: this.abi,
-      logs: [log]
-    })[0];
-    switch (parsedLog.eventName) {
-      case "SetAddress": {
-        const parsedLog2 = viem.parseEventLogs({
-          abi: this.abi,
-          eventName: "SetAddress",
-          logs: [log]
-        })[0];
-        const key = parsedLog2.args.key;
-        this.setInternalAddress(
-          key,
-          parsedLog.args.value,
-          Number(parsedLog2.args.version)
-        );
-        break;
-      }
-      default:
-        this.logger?.warn(`Unknown event: ${parsedLog.eventName}`);
-        break;
-    }
-  }
-};
-var BotListContract = class extends BaseContract {
-  approvedCreditManagers = /* @__PURE__ */ new Set();
-  constructor(sdk, address) {
-    super(sdk, { addr: address, name: "BotListV3", abi: botListV3Abi });
-  }
-  parseFunctionParams(params) {
-    switch (params.functionName) {
-      case "setCreditManagerApprovedStatus": {
-        const [creditManager, status] = params.args;
-        return [this.addressLabels.get(creditManager), `${status}`];
-      }
-      case "setBotSpecialPermissions": {
-        const [bot, creditManager, permissions] = params.args;
-        return [
-          this.addressLabels.get(bot),
-          this.addressLabels.get(creditManager),
-          botPermissionsToString(permissions)
-        ];
-      }
-      default:
-        return void 0;
-    }
-  }
-  async fetchState(toBlock) {
-    const logs = await this.provider.publicClient.getContractEvents({
-      address: this.address,
-      abi: this.abi,
-      fromBlock: 0n,
-      toBlock
-    });
-    logs.forEach((e) => this.parseLog(e));
-  }
-  parseLog(log) {
-    const parsedLog = viem.parseEventLogs({
-      abi: this.abi,
-      logs: [log]
-    })[0];
-    switch (parsedLog.eventName) {
-      case "SetCreditManagerApprovedStatus":
-        if (parsedLog.args.approved) {
-          this.approvedCreditManagers.add(parsedLog.args.creditManager);
-        } else {
-          this.approvedCreditManagers.delete(parsedLog.args.creditManager);
-        }
-        break;
-      case "SetBotSpecialPermissions":
-        this.logger?.debug(
-          `Bot ${parsedLog.args.bot} has been given permissions ${botPermissionsToString(
-            parsedLog.args.permissions
-          )} for credit manager ${parsedLog.args.creditManager}`
-        );
-        break;
-      default:
-        this.logger?.warn(`Unknown event: ${parsedLog.eventName}`);
-        break;
-    }
-  }
-  get state() {
-    return {
-      ...this.contractData
-    };
-  }
-};
-
-// src/sdk/core/GearStakingV3Contract.ts
-var GearStakingContract = class extends BaseContract {
-  constructor(sdk, address) {
-    super(sdk, { addr: address, name: "GearStakingV3", abi: gearStakingV3Abi });
-  }
-  parseFunctionParams(params) {
-    switch (params.functionName) {
-      case "setVotingContractStatus": {
-        const [address, status] = params.args;
-        return [this.addressLabels.get(address), VotingContractStatus[status]];
-      }
-      default:
-        return void 0;
-    }
-  }
-  get state() {
-    return {
-      ...this.contractData,
-      successor: ADDRESS_0X0,
-      migrator: ADDRESS_0X0
-    };
-  }
-};
-
-// src/sdk/market/CreditConfiguratorContract.ts
-var CreditConfiguratorContract = class extends BaseContract {
-  adapters = [];
-  emergencyLiquidators = [];
-  constructor(sdk, { creditConfigurator, creditManager }, emergencyLiquidators) {
-    super(sdk, {
-      ...creditConfigurator.baseParams,
-      name: `CreditConfigurator(${creditManager.name})`,
-      abi: creditConfiguratorV3Abi
-    });
-    this.emergencyLiquidators = [...emergencyLiquidators];
-  }
-  get state() {
-    return {
-      ...this.contractData,
-      emergencyLiquidators: this.emergencyLiquidators
-    };
+  get state() {
+    return {
+      ...this.contractData,
+      emergencyLiquidators: this.emergencyLiquidators
+    };
   }
   parseFunctionParams(params) {
     switch (params.functionName) {
@@ -18666,7 +18176,206 @@ var PoolFactory = class {
       gauge: this.gaugeContract.state
     };
   }
-};
+};
+var SUPPORTED_CHAINS = [
+  "Mainnet",
+  "Arbitrum",
+  "Optimism",
+  "Base"
+];
+var chains = {
+  Mainnet: chains$1.mainnet,
+  Arbitrum: chains$1.arbitrum,
+  Optimism: chains$1.optimism,
+  Base: chains$1.base
+};
+var Provider = class {
+  account;
+  chainId;
+  chain;
+  networkType;
+  publicClient;
+  addressLabels;
+  transport;
+  constructor(opts) {
+    const {
+      account,
+      chainId,
+      networkType,
+      rpcURLs,
+      timeout = 12e4,
+      retryCount
+    } = opts;
+    this.account = account;
+    this.chainId = chainId;
+    this.networkType = networkType;
+    this.chain = viem.defineChain({
+      ...chains[networkType],
+      id: chainId
+    });
+    const rpcs = rpcURLs.map((url) => viem.http(url, { timeout, retryCount }));
+    this.transport = rpcs.length ? viem.fallback(rpcs) : rpcs[0];
+    this.publicClient = viem.createPublicClient({
+      chain: this.chain,
+      transport: this.transport
+    });
+    this.addressLabels = new AddressLabeller();
+  }
+};
+
+// src/sdk/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");
+}
+async function simulateMulticall(client, parameters) {
+  const {
+    account,
+    allowFailure = true,
+    batchSize: batchSize_,
+    blockNumber,
+    blockTag,
+    gas,
+    multicallAddress: multicallAddress_,
+    stateOverride
+  } = 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: abi17, address, args, functionName } = contract;
+    try {
+      const callData = viem.encodeFunctionData({ abi: abi17, 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: abi17,
+        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"
+      )({
+        account,
+        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: abi17, 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: abi17,
+          args,
+          data: returnData,
+          functionName
+        });
+        results.push(allowFailure ? { result: result2, status: "success" } : result2);
+      } catch (err) {
+        const error = viem.getContractError(err, {
+          abi: abi17,
+          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/sdk/market/pricefeeds/PriceFeedRef.ts
 var PriceFeedRef = class {
@@ -18865,101 +18574,460 @@ var ChainlinkPriceFeedContract = class extends AbstractPriceFeedContract {
   get state() {
     return {
       ...this.contractData,
-      contractType: this.priceFeedType,
-      skipCheck: false,
-      pricefeeds: []
+      contractType: this.priceFeedType,
+      skipCheck: false,
+      pricefeeds: []
+    };
+  }
+};
+
+// src/sdk/market/pricefeeds/CompositePriceFeed.ts
+var CompositePriceFeedContract = class extends AbstractPriceFeedContract {
+  constructor(sdk, args) {
+    super(sdk, {
+      ...args,
+      name: "CompositePriceFeed",
+      abi: compositePriceFeedAbi,
+      decimals: 8
+    });
+  }
+  get targetToBasePriceFeed() {
+    return this.underlyingPriceFeeds[0];
+  }
+  get baseToUsdPriceFeed() {
+    return this.underlyingPriceFeeds[1];
+  }
+  get state() {
+    return {
+      ...this.contractData,
+      contractType: this.priceFeedType,
+      pricefeeds: [
+        this.targetToBasePriceFeed.state,
+        this.baseToUsdPriceFeed.state
+      ],
+      skipCheck: true
+    };
+  }
+};
+
+// src/sdk/market/pricefeeds/CurveCryptoPriceFeed.ts
+var CurveCryptoPriceFeedContract = class extends AbstractLPPriceFeedContract {
+  constructor(sdk, args) {
+    super(sdk, {
+      ...args,
+      name: "CurveCryptoPriceFeed",
+      abi: curveCryptoLpPriceFeedAbi
+    });
+  }
+  get state() {
+    return {
+      ...this.contractData,
+      contractType: this.priceFeedType,
+      skipCheck: true,
+      pricefeeds: this.underlyingPriceFeeds.map((pf) => pf.state)
+    };
+  }
+  async getValue() {
+    return await this.sdk.provider.publicClient.readContract({
+      abi: iCurvePoolAbi,
+      address: this.lpContract,
+      functionName: "get_virtual_price"
+    });
+  }
+};
+
+// src/sdk/market/pricefeeds/CurveStablePriceFeed.ts
+var CurveStablePriceFeedContract = class extends AbstractLPPriceFeedContract {
+  constructor(sdk, args) {
+    super(sdk, {
+      ...args,
+      name: "CurveStablePriceFeed",
+      abi: curveStableLpPriceFeedAbi
+    });
+  }
+  get state() {
+    return {
+      ...this.contractData,
+      contractType: this.priceFeedType,
+      skipCheck: true,
+      pricefeeds: this.underlyingPriceFeeds.map((pf) => pf.state)
+    };
+  }
+  async getValue() {
+    return await this.sdk.provider.publicClient.readContract({
+      abi: iCurvePoolAbi,
+      address: this.lpContract,
+      functionName: "get_virtual_price"
+    });
+  }
+};
+
+// src/sdk/market/pricefeeds/CurveUSDPriceFeed.ts
+var CurveUSDPriceFeedContract = class extends AbstractLPPriceFeedContract {
+  constructor(sdk, args) {
+    super(sdk, {
+      ...args,
+      name: "CurveUSDPriceFeed",
+      abi: curveUsdPriceFeedAbi
+    });
+  }
+  get state() {
+    return {
+      ...this.contractData,
+      contractType: this.priceFeedType,
+      skipCheck: true,
+      pricefeeds: [this.underlyingPriceFeeds[0].state]
+    };
+  }
+  async getValue() {
+    return await this.sdk.provider.publicClient.readContract({
+      abi: iCurvePoolAbi,
+      address: this.lpContract,
+      functionName: "get_virtual_price"
+    });
+  }
+};
+var Erc4626PriceFeedContract = class extends AbstractLPPriceFeedContract {
+  constructor(sdk, args) {
+    super(sdk, {
+      ...args,
+      name: "ERC4626PriceFeed",
+      abi: erc4626PriceFeedAbi
+    });
+  }
+  get state() {
+    return {
+      ...this.contractData,
+      contractType: this.priceFeedType,
+      skipCheck: true,
+      pricefeeds: [this.underlyingPriceFeeds[0].state]
+    };
+  }
+  async getValue() {
+    const decimals2 = await this.sdk.provider.publicClient.readContract({
+      abi: erc20Abi,
+      address: this.lpContract,
+      functionName: "decimals"
+    });
+    const price = await this.sdk.provider.publicClient.readContract({
+      abi: viem.erc4626Abi,
+      address: this.lpContract,
+      functionName: "convertToAssets",
+      args: [10n ** BigInt(decimals2)]
+    });
+    return price;
+  }
+};
+
+// src/sdk/market/pricefeeds/MellowLRTPriceFeed.ts
+var MellowLRTPriceFeedContract = class extends AbstractLPPriceFeedContract {
+  constructor(sdk, args) {
+    super(sdk, {
+      ...args,
+      name: "MellowLRTPriceFeed",
+      abi: mellowLrtPriceFeedAbi
+    });
+  }
+  get state() {
+    return {
+      ...this.contractData,
+      contractType: this.priceFeedType,
+      skipCheck: true,
+      pricefeeds: [this.underlyingPriceFeeds[0].state]
+    };
+  }
+  async getValue() {
+    const stack = await this.sdk.provider.publicClient.readContract({
+      abi: iMellowVaultAbi,
+      address: this.lpContract,
+      functionName: "calculateStack"
+    });
+    return stack.totalValue * BigInt(1e18) / stack.totalSupply;
+  }
+};
+
+// src/sdk/utils/internal/Hooks.ts
+var Hooks = class {
+  #reg = {};
+  addHook(hookName, fn) {
+    if (!this.#reg[hookName]) {
+      this.#reg[hookName] = [];
+    }
+    this.#reg[hookName].push(fn);
+  }
+  removeHook(hookName, fn) {
+    if (!this.#reg[hookName]) {
+      return;
+    }
+    this.#reg[hookName] = this.#reg[hookName]?.filter((hookFn) => hookFn !== fn) ?? [];
+  }
+  async triggerHooks(hookName, ...args) {
+    if (!this.#reg[hookName]) {
+      return;
+    }
+    for (const fn of this.#reg[hookName]) {
+      await fn(...args);
+    }
+  }
+};
+var RedstonePriceFeedContract = class extends AbstractPriceFeedContract {
+  decimals = 8;
+  dataServiceId;
+  dataId;
+  signers;
+  signersThreshold;
+  constructor(sdk, args) {
+    super(sdk, {
+      ...args,
+      name: `RedstonePriceFeed`,
+      abi: redstonePriceFeedAbi
+    });
+    const decoder = viem.decodeAbiParameters(
+      [
+        { type: "address" },
+        //  [0]: pf.token(),
+        { type: "bytes32" },
+        //  [1]: pf.dataFeedId(),
+        { type: "address" },
+        //  [2]: pf.signerAddress0(),
+        { type: "address" },
+        //  [3]: pf.signerAddress1(),
+        { type: "address" },
+        //  [4]: pf.signerAddress2(),
+        { type: "address" },
+        //  [5]: pf.signerAddress3(),
+        { type: "address" },
+        //  [6]: pf.signerAddress4(),
+        { type: "address" },
+        //  [7]: pf.signerAddress5()
+        { type: "address" },
+        //  [8]: pf.signerAddress6(),
+        { type: "address" },
+        //  [9]: pf.signerAddress7(),
+        { type: "address" },
+        // [10]: pf.signerAddress8(),
+        { type: "address" },
+        // [11]: pf.signerAddress9(),
+        { type: "uint8" },
+        //   [12]: pf.getUniqueSignersThreshold()
+        { type: "uint128" },
+        // [13]: pf.lastPrice(),
+        { type: "uint40" }
+        //  [14]: pf.lastPayloadTimestamp()
+      ],
+      args.baseParams.serializedParams
+    );
+    this.dataId = viem.bytesToString(viem.toBytes(decoder[1])).replaceAll("\0", "");
+    this.signers = decoder.slice(2, 11);
+    this.signersThreshold = Number(decoder[12]);
+    this.dataServiceId = ["GMX", "BAL"].includes(this.dataId) ? "redstone-arbitrum-prod" : "redstone-primary-prod";
+  }
+  get state() {
+    return {
+      ...this.contractData,
+      contractType: "PF_REDSTONE_ORACLE",
+      dataId: this.dataId,
+      signers: this.signers,
+      signersThreshold: this.signersThreshold,
+      skipCheck: true
     };
   }
 };
-
-// src/sdk/market/pricefeeds/CompositePriceFeed.ts
-var CompositePriceFeedContract = class extends AbstractPriceFeedContract {
-  constructor(sdk, args) {
-    super(sdk, {
-      ...args,
-      name: "CompositePriceFeed",
-      abi: compositePriceFeedAbi,
-      decimals: 8
-    });
+var RedstoneUpdater = class extends SDKConstruct {
+  #logger;
+  #cache = /* @__PURE__ */ new Map();
+  #historicalTimestamp;
+  constructor(sdk) {
+    super(sdk);
+    this.#logger = childLogger("RedstoneUpdater", sdk.logger);
   }
-  get targetToBasePriceFeed() {
-    return this.underlyingPriceFeeds[0];
+  setHistoricalTimestamp(timestamp) {
+    this.#historicalTimestamp = timestamp;
   }
-  get baseToUsdPriceFeed() {
-    return this.underlyingPriceFeeds[1];
+  async getUpdateTxs(feeds) {
+    this.#logger?.debug(
+      `generating update transactions for ${feeds.length} redstone price feeds`
+    );
+    const groupedFeeds = {};
+    const priceFeeds = /* @__PURE__ */ new Map();
+    for (const feed of feeds) {
+      const key = `${feed.dataServiceId}:${feed.signersThreshold}`;
+      if (!groupedFeeds[key]) {
+        groupedFeeds[key] = /* @__PURE__ */ new Set();
+      }
+      groupedFeeds[key].add(feed.dataId);
+      priceFeeds.set(feed.dataId, feed);
+    }
+    const results = [];
+    for (const [key, group] of Object.entries(groupedFeeds)) {
+      const [dataServiceId, signersStr] = key.split(":");
+      const uniqueSignersCount = parseInt(signersStr, 10);
+      this.#logger?.debug(
+        `fetching redstone payloads for ${group.size} data feeds in ${dataServiceId} with ${uniqueSignersCount} signers: ${Array.from(group).join(", ")}`
+      );
+      const payloads = await this.#getPayloads(
+        dataServiceId,
+        group,
+        uniqueSignersCount
+      );
+      for (const { dataFeedId, data, timestamp } of payloads) {
+        const priceFeed = priceFeeds.get(dataFeedId);
+        if (!priceFeed) {
+          throw new Error(`cannot get price feed address for ${dataFeedId}`);
+        }
+        results.push({
+          priceFeed: priceFeed.address.toLowerCase(),
+          tx: priceFeed.createRawTx({
+            functionName: "updatePrice",
+            args: [data],
+            description: `updating price for ${dataFeedId} [${priceFeed.address}]`
+          }),
+          timestamp
+        });
+      }
+    }
+    this.#logger?.debug(
+      `generated  ${results.length} update transactions for redstone price feeds`
+    );
+    return results;
   }
-  get state() {
-    return {
-      ...this.contractData,
-      contractType: this.priceFeedType,
-      pricefeeds: [
-        this.targetToBasePriceFeed.state,
-        this.baseToUsdPriceFeed.state
-      ],
-      skipCheck: true
-    };
+  /**
+   * Gets redstone payloads in one request for multiple feeds with the same dataServiceId and uniqueSignersCount
+   * If historicalTimestamp is set, responses will be cached
+   * @param dataServiceId
+   * @param dataFeedsIds
+   * @param uniqueSignersCount
+   * @returns
+   */
+  async #getPayloads(dataServiceId, dataFeedsIds, uniqueSignersCount) {
+    const fromCache = [];
+    const uncached = [];
+    for (const dataFeedId of dataFeedsIds) {
+      const key = cacheKey(
+        dataServiceId,
+        dataFeedId,
+        uniqueSignersCount,
+        this.#historicalTimestamp
+      );
+      const cached = this.#cache.get(key);
+      if (this.#historicalTimestamp && !!cached) {
+        fromCache.push(cached);
+      } else {
+        uncached.push(dataFeedId);
+      }
+    }
+    const fromRedstone = await this.#fetchPayloads(
+      dataServiceId,
+      new Set(uncached),
+      uniqueSignersCount
+    );
+    if (this.#historicalTimestamp) {
+      for (const resp of fromRedstone) {
+        const key = cacheKey(
+          dataServiceId,
+          resp.dataFeedId,
+          uniqueSignersCount,
+          this.#historicalTimestamp
+        );
+        this.#cache.set(key, resp);
+      }
+    }
+    return [...fromCache, ...fromRedstone];
   }
-};
-
-// src/sdk/market/pricefeeds/CurveCryptoPriceFeed.ts
-var CurveCryptoPriceFeedContract = class extends AbstractLPPriceFeedContract {
-  constructor(sdk, args) {
-    super(sdk, {
-      ...args,
-      name: "CurveCryptoPriceFeed",
-      abi: curveCryptoLpPriceFeedAbi
+  /**
+   * Fetches redstone payloads in one request for multiple feeds with the same dataServiceId and uniqueSignersCount
+   * Payloads are loaded in one request to avoid redstone rate limit
+   * @param dataServiceId
+   * @param dataFeedsIds
+   * @param uniqueSignersCount
+   * @returns
+   */
+  async #fetchPayloads(dataServiceId, dataFeedsIds, uniqueSignersCount) {
+    if (dataFeedsIds.size === 0) {
+      return [];
+    }
+    const dataPackagesIds = Array.from(dataFeedsIds);
+    const wrapper = new evmConnector.DataServiceWrapper({
+      dataServiceId,
+      dataPackagesIds,
+      uniqueSignersCount,
+      historicalTimestamp: this.#historicalTimestamp
     });
-  }
-  get state() {
-    return {
-      ...this.contractData,
-      contractType: this.priceFeedType,
-      skipCheck: true,
-      pricefeeds: this.underlyingPriceFeeds.map((pf) => pf.state)
-    };
-  }
-  async getValue() {
-    return await this.sdk.provider.publicClient.readContract({
-      abi: iCurvePoolAbi,
-      address: this.lpContract,
-      functionName: "get_virtual_price"
+    const dataPayload = await wrapper.prepareRedstonePayload(true);
+    const parsed = redstoneProtocol.RedstonePayload.parse(viem.toBytes(`0x${dataPayload}`));
+    const packagesByDataFeedId = groupDataPackages(parsed.signedDataPackages);
+    return dataPackagesIds.map((dataFeedId) => {
+      const signedDataPackages = packagesByDataFeedId[dataFeedId];
+      if (!signedDataPackages) {
+        throw new Error(`cannot find data packages for ${dataFeedId}`);
+      }
+      if (signedDataPackages.length !== uniqueSignersCount) {
+        throw new Error(
+          `got ${signedDataPackages.length} data packages for ${dataFeedId}, but expected ${uniqueSignersCount}`
+        );
+      }
+      return getCalldataWithTimestamp(
+        dataFeedId,
+        signedDataPackages,
+        wrapper.getUnsignedMetadata()
+      );
     });
   }
 };
-
-// src/sdk/market/pricefeeds/CurveStablePriceFeed.ts
-var CurveStablePriceFeedContract = class extends AbstractLPPriceFeedContract {
-  constructor(sdk, args) {
-    super(sdk, {
-      ...args,
-      name: "CurveStablePriceFeed",
-      abi: curveStableLpPriceFeedAbi
-    });
-  }
-  get state() {
-    return {
-      ...this.contractData,
-      contractType: this.priceFeedType,
-      skipCheck: true,
-      pricefeeds: this.underlyingPriceFeeds.map((pf) => pf.state)
-    };
+function cacheKey(dataServiceId, dataFeedId, uniqueSignersCount, historicalTimestamp = 0) {
+  return `${dataServiceId}:${dataFeedId}:${uniqueSignersCount}:${historicalTimestamp}`;
+}
+function groupDataPackages(signedDataPackages) {
+  const packagesByDataFeedId = {};
+  for (const p of signedDataPackages) {
+    const { dataPoints } = p.dataPackage;
+    const dataFeedId0 = dataPoints[0].dataFeedId;
+    for (const dp of dataPoints) {
+      if (dp.dataFeedId !== dataFeedId0) {
+        throw new Error(
+          `data package contains data points with different dataFeedIds: ${dp.dataFeedId} and ${dataFeedId0}`
+        );
+      }
+    }
+    if (!packagesByDataFeedId[dataFeedId0]) {
+      packagesByDataFeedId[dataFeedId0] = [];
+    }
+    packagesByDataFeedId[dataFeedId0].push(p);
   }
-  async getValue() {
-    return await this.sdk.provider.publicClient.readContract({
-      abi: iCurvePoolAbi,
-      address: this.lpContract,
-      functionName: "get_virtual_price"
-    });
+  return packagesByDataFeedId;
+}
+function getCalldataWithTimestamp(dataFeedId, packages, unsignedMetadata) {
+  const originalPayload = redstoneProtocol.RedstonePayload.prepare(packages, unsignedMetadata);
+  const originalPayloadLength = originalPayload.length / 2;
+  const bytesToAdd = 32 - originalPayloadLength % 32;
+  const newUnsignedMetadata = unsignedMetadata + "_".repeat(bytesToAdd);
+  const payload = redstoneProtocol.RedstonePayload.prepare(packages, newUnsignedMetadata);
+  let timestamp = 0;
+  for (const p of packages) {
+    const newTimestamp = p.dataPackage.timestampMilliseconds / 1e3;
+    if (timestamp === 0) {
+      timestamp = newTimestamp;
+    } else if (timestamp !== newTimestamp) {
+      throw new Error("Timestamps are not equal");
+    }
   }
-};
+  return {
+    dataFeedId,
+    data: viem.encodeAbiParameters(
+      [{ type: "uint256" }, { type: "bytes" }],
+      [BigInt(timestamp), `0x${payload}`]
+    ),
+    timestamp
+  };
+}
 
-// src/sdk/market/pricefeeds/CurveUSDPriceFeed.ts
-var CurveUSDPriceFeedContract = class extends AbstractLPPriceFeedContract {
+// src/sdk/market/pricefeeds/WstETHPriceFeed.ts
+var WstETHPriceFeedContract = class extends AbstractLPPriceFeedContract {
   constructor(sdk, args) {
     super(sdk, {
       ...args,
-      name: "CurveUSDPriceFeed",
-      abi: curveUsdPriceFeedAbi
+      name: "WstETHPriceFeed",
+      abi: wstEthPriceFeedAbi
     });
   }
   get state() {
@@ -18972,18 +19040,20 @@ var CurveUSDPriceFeedContract = class extends AbstractLPPriceFeedContract {
   }
   async getValue() {
     return await this.sdk.provider.publicClient.readContract({
-      abi: iCurvePoolAbi,
+      abi: iwstEthAbi,
       address: this.lpContract,
-      functionName: "get_virtual_price"
+      functionName: "stEthPerToken"
     });
   }
 };
-var Erc4626PriceFeedContract = class extends AbstractLPPriceFeedContract {
+
+// src/sdk/market/pricefeeds/YearnPriceFeed.ts
+var YearnPriceFeedContract = class extends AbstractLPPriceFeedContract {
   constructor(sdk, args) {
     super(sdk, {
       ...args,
-      name: "ERC4626PriceFeed",
-      abi: erc4626PriceFeedAbi
+      name: "YearnPriceFeed",
+      abi: yearnPriceFeedAbi
     });
   }
   get state() {
@@ -18995,878 +19065,1028 @@ var Erc4626PriceFeedContract = class extends AbstractLPPriceFeedContract {
     };
   }
   async getValue() {
-    const decimals2 = await this.sdk.provider.publicClient.readContract({
-      abi: erc20Abi,
-      address: this.lpContract,
-      functionName: "decimals"
-    });
-    const price = await this.sdk.provider.publicClient.readContract({
-      abi: viem.erc4626Abi,
+    return await this.sdk.provider.publicClient.readContract({
+      abi: iyVaultAbi,
       address: this.lpContract,
-      functionName: "convertToAssets",
-      args: [10n ** BigInt(decimals2)]
+      functionName: "pricePerShare"
     });
-    return price;
   }
 };
 
-// src/sdk/market/pricefeeds/MellowLRTPriceFeed.ts
-var MellowLRTPriceFeedContract = class extends AbstractLPPriceFeedContract {
+// src/sdk/market/pricefeeds/ZeroPriceFeed.ts
+var ZeroPriceFeedContract = class extends AbstractPriceFeedContract {
   constructor(sdk, args) {
     super(sdk, {
       ...args,
-      name: "MellowLRTPriceFeed",
-      abi: mellowLrtPriceFeedAbi
+      name: "ZeroPriceFeed",
+      abi: zeroPriceFeedAbi,
+      decimals: 8
     });
   }
   get state() {
     return {
       ...this.contractData,
-      contractType: this.priceFeedType,
+      contractType: "PF_ZERO_ORACLE",
       skipCheck: true,
-      pricefeeds: [this.underlyingPriceFeeds[0].state]
+      stalenessPeriod: 0,
+      pricefeeds: []
     };
   }
-  async getValue() {
-    const stack = await this.sdk.provider.publicClient.readContract({
-      abi: iMellowVaultAbi,
-      address: this.lpContract,
-      functionName: "calculateStack"
-    });
-    return stack.totalValue * BigInt(1e18) / stack.totalSupply;
-  }
 };
 
-// src/sdk/utils/internal/Hooks.ts
-var Hooks = class {
-  #reg = {};
-  addHook(hookName, fn) {
-    if (!this.#reg[hookName]) {
-      this.#reg[hookName] = [];
-    }
-    this.#reg[hookName].push(fn);
-  }
-  removeHook(hookName, fn) {
-    if (!this.#reg[hookName]) {
-      return;
-    }
-    this.#reg[hookName] = this.#reg[hookName]?.filter((hookFn) => hookFn !== fn) ?? [];
+// src/sdk/market/pricefeeds/PriceFeedsRegister.ts
+var PriceFeedRegister = class extends SDKConstruct {
+  logger;
+  #hooks = new Hooks();
+  #feeds = new AddressMap();
+  #redstoneUpdater;
+  // public readonly zeroPriceFeed: ZeroPriceFeedContract;
+  constructor(sdk) {
+    super(sdk);
+    this.logger = childLogger("PriceFeedRegister", sdk.logger);
+    this.#redstoneUpdater = new RedstoneUpdater(sdk);
   }
-  async triggerHooks(hookName, ...args) {
-    if (!this.#reg[hookName]) {
-      return;
+  addHook = this.#hooks.addHook.bind(this.#hooks);
+  removeHook = this.#hooks.removeHook.bind(this.#hooks);
+  /**
+   * Returns RawTxs to update price feeds
+   * @param priceFeeds top-level price feeds, actual updatable price feeds will be derived. If not provided will use all price feeds that are attached
+   * @returns
+   */
+  async generatePriceFeedsUpdateTxs(priceFeeds) {
+    const priceFeedz = priceFeeds ?? Object.values(this.#feeds);
+    const updateables = priceFeedz.flatMap((pf) => pf.updatableDependencies());
+    const txs = [];
+    const redstonePFs = [];
+    for (const pf of updateables) {
+      if (pf instanceof RedstonePriceFeedContract) {
+        redstonePFs.push(pf);
+      }
     }
-    for (const fn of this.#reg[hookName]) {
-      await fn(...args);
+    let maxTimestamp = 0;
+    if (redstonePFs.length > 0) {
+      const redstoneUpdates = await this.#redstoneUpdater.getUpdateTxs(redstonePFs);
+      for (const { tx, timestamp } of redstoneUpdates) {
+        if (timestamp > maxTimestamp) {
+          maxTimestamp = timestamp;
+        }
+        txs.push(tx);
+      }
     }
+    const result = { txs, timestamp: maxTimestamp };
+    await this.#hooks.triggerHooks("updatesGenerated", result);
+    return result;
   }
-};
-var RedstonePriceFeedContract = class extends AbstractPriceFeedContract {
-  decimals = 8;
-  dataServiceId;
-  dataId;
-  signers;
-  signersThreshold;
-  constructor(sdk, args) {
-    super(sdk, {
-      ...args,
-      name: `RedstonePriceFeed`,
-      abi: redstonePriceFeedAbi
-    });
-    const decoder = viem.decodeAbiParameters(
-      [
-        { type: "address" },
-        //  [0]: pf.token(),
-        { type: "bytes32" },
-        //  [1]: pf.dataFeedId(),
-        { type: "address" },
-        //  [2]: pf.signerAddress0(),
-        { type: "address" },
-        //  [3]: pf.signerAddress1(),
-        { type: "address" },
-        //  [4]: pf.signerAddress2(),
-        { type: "address" },
-        //  [5]: pf.signerAddress3(),
-        { type: "address" },
-        //  [6]: pf.signerAddress4(),
-        { type: "address" },
-        //  [7]: pf.signerAddress5()
-        { type: "address" },
-        //  [8]: pf.signerAddress6(),
-        { type: "address" },
-        //  [9]: pf.signerAddress7(),
-        { type: "address" },
-        // [10]: pf.signerAddress8(),
-        { type: "address" },
-        // [11]: pf.signerAddress9(),
-        { type: "uint8" },
-        //   [12]: pf.getUniqueSignersThreshold()
-        { type: "uint128" },
-        // [13]: pf.lastPrice(),
-        { type: "uint40" }
-        //  [14]: pf.lastPayloadTimestamp()
-      ],
-      args.baseParams.serializedParams
-    );
-    this.dataId = viem.bytesToString(viem.toBytes(decoder[1])).replaceAll("\0", "");
-    this.signers = decoder.slice(2, 11);
-    this.signersThreshold = Number(decoder[12]);
-    this.dataServiceId = ["GMX", "BAL"].includes(this.dataId) ? "redstone-arbitrum-prod" : "redstone-primary-prod";
+  get(address) {
+    return this.#feeds.get(address);
   }
-  get state() {
-    return {
-      ...this.contractData,
-      contractType: "PF_REDSTONE_ORACLE",
-      dataId: this.dataId,
-      signers: this.signers,
-      signersThreshold: this.signersThreshold,
-      skipCheck: true
-    };
+  mustGet(address) {
+    return this.#feeds.mustGet(address);
   }
-};
-var RedstoneUpdater = class extends SDKConstruct {
-  #logger;
-  #cache = /* @__PURE__ */ new Map();
-  #historicalTimestamp;
-  constructor(sdk) {
-    super(sdk);
-    this.#logger = childLogger("RedstoneUpdater", sdk.logger);
+  create(data) {
+    const feed = this.#create(data);
+    this.#feeds.upsert(data.baseParams.addr, feed);
+    return feed;
   }
-  setHistoricalTimestamp(timestamp) {
-    this.#historicalTimestamp = timestamp;
+  /**
+   * Set redstone historical timestamp
+   * @param timestampMs in milliseconds
+   */
+  setRedstoneHistoricalTimestamp(timestampMs) {
+    this.#redstoneUpdater.setHistoricalTimestamp(timestampMs);
   }
-  async getUpdateTxs(feeds) {
-    this.#logger?.debug(
-      `generating update transactions for ${feeds.length} redstone price feeds`
+  #create(data) {
+    const contractType = bytes32ToString(
+      data.baseParams.contractType
     );
-    const groupedFeeds = {};
-    const priceFeeds = /* @__PURE__ */ new Map();
-    for (const feed of feeds) {
-      const key = `${feed.dataServiceId}:${feed.signersThreshold}`;
-      if (!groupedFeeds[key]) {
-        groupedFeeds[key] = /* @__PURE__ */ new Set();
-      }
-      groupedFeeds[key].add(feed.dataId);
-      priceFeeds.set(feed.dataId, feed);
+    switch (contractType) {
+      case "PF_CHAINLINK_ORACLE":
+        return new ChainlinkPriceFeedContract(this.sdk, data);
+      case "PF_YEARN_ORACLE":
+        return new YearnPriceFeedContract(this.sdk, data);
+      case "PF_CURVE_STABLE_LP_ORACLE":
+        return new CurveStablePriceFeedContract(this.sdk, data);
+      case "PF_WSTETH_ORACLE":
+        return new WstETHPriceFeedContract(this.sdk, data);
+      case "PF_BOUNDED_ORACLE":
+        return new BoundedPriceFeedContract(this.sdk, data);
+      case "PF_COMPOSITE_ORACLE":
+        return new CompositePriceFeedContract(this.sdk, data);
+      case "PF_BALANCER_STABLE_LP_ORACLE":
+        return new BalancerStablePriceFeedContract(this.sdk, data);
+      case "PF_BALANCER_WEIGHTED_LP_ORACLE":
+        return new BalancerWeightedPriceFeedContract(this.sdk, data);
+      case "PF_CURVE_CRYPTO_LP_ORACLE":
+        return new CurveCryptoPriceFeedContract(this.sdk, data);
+      case "PF_REDSTONE_ORACLE":
+        return new RedstonePriceFeedContract(this.sdk, data);
+      case "PF_ERC4626_ORACLE":
+        return new Erc4626PriceFeedContract(this.sdk, data);
+      case "PF_CURVE_USD_ORACLE":
+        return new CurveUSDPriceFeedContract(this.sdk, data);
+      case "PF_ZERO_ORACLE":
+        return new ZeroPriceFeedContract(this.sdk, data);
+      case "PF_MELLOW_LRT_ORACLE":
+        return new MellowLRTPriceFeedContract(this.sdk, data);
+      default:
+        throw new Error(`Price feed type ${contractType} not supported, `);
+    }
+  }
+};
+function rawTxToMulticallPriceUpdate(tx) {
+  const { to, callData } = tx;
+  const { args, functionName } = viem.decodeFunctionData({
+    abi: iUpdatablePriceFeedAbi,
+    data: callData
+  });
+  return {
+    abi: iUpdatablePriceFeedAbi,
+    address: to,
+    functionName,
+    args
+  };
+}
+
+// src/sdk/market/PriceOracleContract.ts
+var PriceOracleContract = class extends BaseContract {
+  /**
+   * Underlying token of market to which this price oracle belongs
+   */
+  underlying;
+  /**
+   * Mapping Token => [PriceFeed Address, stalenessPeriod]
+   */
+  mainPriceFeeds = {};
+  /**
+   * Mapping Token => [PriceFeed Address, stalenessPeriod]
+   */
+  reservePriceFeeds = {};
+  /**
+   * Mapping Token => Price in underlying
+   */
+  mainPrices = new AddressMap();
+  /**
+   * Mapping Token => Price in underlying
+   */
+  reservePrices = new AddressMap();
+  #priceFeedTree;
+  constructor(sdk, data, underlying) {
+    super(sdk, {
+      ...data.baseParams,
+      name: "PriceOracleV3",
+      abi: priceOracleV3Abi
+    });
+    this.underlying = underlying;
+    const { priceFeedMapping, priceFeedStructure } = data;
+    this.#priceFeedTree = priceFeedStructure;
+    for (const node of priceFeedStructure) {
+      sdk.priceFeeds.create(node);
     }
-    const results = [];
-    for (const [key, group] of Object.entries(groupedFeeds)) {
-      const [dataServiceId, signersStr] = key.split(":");
-      const uniqueSignersCount = parseInt(signersStr, 10);
-      this.#logger?.debug(
-        `fetching redstone payloads for ${group.size} data feeds in ${dataServiceId} with ${uniqueSignersCount} signers: ${Array.from(group).join(", ")}`
-      );
-      const payloads = await this.#getPayloads(
-        dataServiceId,
-        group,
-        uniqueSignersCount
-      );
-      for (const { dataFeedId, data, timestamp } of payloads) {
-        const priceFeed = priceFeeds.get(dataFeedId);
-        if (!priceFeed) {
-          throw new Error(`cannot get price feed address for ${dataFeedId}`);
+    priceFeedMapping.forEach((node) => {
+      const { token, priceFeed, reserve, stalenessPeriod } = node;
+      const ref = new PriceFeedRef(sdk, priceFeed, stalenessPeriod);
+      const price = this.#priceFeedTree.find(
+        (n) => n.baseParams.addr === priceFeed
+      )?.answer?.price;
+      if (reserve) {
+        this.reservePriceFeeds[token] = ref;
+        if (price) {
+          this.reservePrices.upsert(token, price);
+        }
+      } else {
+        this.mainPriceFeeds[token] = ref;
+        if (price) {
+          this.mainPrices.upsert(token, price);
         }
-        results.push({
-          priceFeed: priceFeed.address.toLowerCase(),
-          tx: priceFeed.createRawTx({
-            functionName: "updatePrice",
-            args: [data],
-            description: `updating price for ${dataFeedId} [${priceFeed.address}]`
-          }),
-          timestamp
-        });
       }
-    }
-    this.#logger?.debug(
-      `generated  ${results.length} update transactions for redstone price feeds`
+      this.#labelPriceFeed(priceFeed, reserve ? "Reserve" : "Main", token);
+    });
+    this.logger?.debug(
+      `Got ${Object.keys(this.mainPriceFeeds).length} main and ${Object.keys(this.reservePriceFeeds).length} reserve price feeds`
     );
-    return results;
   }
   /**
-   * Gets redstone payloads in one request for multiple feeds with the same dataServiceId and uniqueSignersCount
-   * If historicalTimestamp is set, responses will be cached
-   * @param dataServiceId
-   * @param dataFeedsIds
-   * @param uniqueSignersCount
+   * Returns main and reserve price feeds for given tokens
+   * @param tokens
+   * @param opts Option to include main/reserve feeds only, defaults to both
    * @returns
    */
-  async #getPayloads(dataServiceId, dataFeedsIds, uniqueSignersCount) {
-    const fromCache = [];
-    const uncached = [];
-    for (const dataFeedId of dataFeedsIds) {
-      const key = cacheKey(
-        dataServiceId,
-        dataFeedId,
-        uniqueSignersCount,
-        this.#historicalTimestamp
-      );
-      const cached = this.#cache.get(key);
-      if (this.#historicalTimestamp && !!cached) {
-        fromCache.push(cached);
-      } else {
-        uncached.push(dataFeedId);
-      }
-    }
-    const fromRedstone = await this.#fetchPayloads(
-      dataServiceId,
-      new Set(uncached),
-      uniqueSignersCount
-    );
-    if (this.#historicalTimestamp) {
-      for (const resp of fromRedstone) {
-        const key = cacheKey(
-          dataServiceId,
-          resp.dataFeedId,
-          uniqueSignersCount,
-          this.#historicalTimestamp
-        );
-        this.#cache.set(key, resp);
-      }
-    }
-    return [...fromCache, ...fromRedstone];
+  priceFeedsForTokens(tokens, opts) {
+    const main = opts?.main ?? true;
+    const reserve = opts?.reserve ?? true;
+    return tokens.flatMap((t) => [
+      main ? this.mainPriceFeeds[t]?.priceFeed : void 0,
+      reserve ? this.reservePriceFeeds[t]?.priceFeed : void 0
+    ]).filter((f) => !!f);
   }
   /**
-   * Fetches redstone payloads in one request for multiple feeds with the same dataServiceId and uniqueSignersCount
-   * Payloads are loaded in one request to avoid redstone rate limit
-   * @param dataServiceId
-   * @param dataFeedsIds
-   * @param uniqueSignersCount
+   * Generates updates for all updateable price feeds in this oracle (including dependencies)
    * @returns
    */
-  async #fetchPayloads(dataServiceId, dataFeedsIds, uniqueSignersCount) {
-    if (dataFeedsIds.size === 0) {
-      return [];
-    }
-    const dataPackagesIds = Array.from(dataFeedsIds);
-    const wrapper = new evmConnector.DataServiceWrapper({
-      dataServiceId,
-      dataPackagesIds,
-      uniqueSignersCount,
-      historicalTimestamp: this.#historicalTimestamp
-    });
-    const dataPayload = await wrapper.prepareRedstonePayload(true);
-    const parsed = redstoneProtocol.RedstonePayload.parse(viem.toBytes(`0x${dataPayload}`));
-    const packagesByDataFeedId = groupDataPackages(parsed.signedDataPackages);
-    return dataPackagesIds.map((dataFeedId) => {
-      const signedDataPackages = packagesByDataFeedId[dataFeedId];
-      if (!signedDataPackages) {
-        throw new Error(`cannot find data packages for ${dataFeedId}`);
-      }
-      if (signedDataPackages.length !== uniqueSignersCount) {
-        throw new Error(
-          `got ${signedDataPackages.length} data packages for ${dataFeedId}, but expected ${uniqueSignersCount}`
-        );
+  async updatePriceFeeds() {
+    const updatables = [];
+    for (const node of this.#priceFeedTree) {
+      if (node.updatable) {
+        updatables.push(this.sdk.priceFeeds.mustGet(node.baseParams.addr));
       }
-      return getCalldataWithTimestamp(
-        dataFeedId,
-        signedDataPackages,
-        wrapper.getUnsignedMetadata()
-      );
-    });
+    }
+    return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(updatables);
   }
-};
-function cacheKey(dataServiceId, dataFeedId, uniqueSignersCount, historicalTimestamp = 0) {
-  return `${dataServiceId}:${dataFeedId}:${uniqueSignersCount}:${historicalTimestamp}`;
-}
-function groupDataPackages(signedDataPackages) {
-  const packagesByDataFeedId = {};
-  for (const p of signedDataPackages) {
-    const { dataPoints } = p.dataPackage;
-    const dataFeedId0 = dataPoints[0].dataFeedId;
-    for (const dp of dataPoints) {
-      if (dp.dataFeedId !== dataFeedId0) {
-        throw new Error(
-          `data package contains data points with different dataFeedIds: ${dp.dataFeedId} and ${dataFeedId0}`
-        );
-      }
+  /**
+   * Converts previously obtained price updates into CreditFacade multicall entries
+   * @param creditFacade
+   * @param updates
+   * @returns
+   */
+  onDemandPriceUpdates(updates) {
+    const result = [];
+    if (!updates) {
+      return result;
     }
-    if (!packagesByDataFeedId[dataFeedId0]) {
-      packagesByDataFeedId[dataFeedId0] = [];
+    const { txs } = updates;
+    for (const tx of txs) {
+      const { to: priceFeed, callData } = tx;
+      const [token, reserve] = this.#findTokenForPriceFeed(priceFeed);
+      const { args } = viem.decodeFunctionData({
+        abi: iUpdatablePriceFeedAbi,
+        data: callData
+      });
+      const data = args[0];
+      result.push({
+        token,
+        reserve,
+        data
+      });
     }
-    packagesByDataFeedId[dataFeedId0].push(p);
+    return result;
   }
-  return packagesByDataFeedId;
-}
-function getCalldataWithTimestamp(dataFeedId, packages, unsignedMetadata) {
-  const originalPayload = redstoneProtocol.RedstonePayload.prepare(packages, unsignedMetadata);
-  const originalPayloadLength = originalPayload.length / 2;
-  const bytesToAdd = 32 - originalPayloadLength % 32;
-  const newUnsignedMetadata = unsignedMetadata + "_".repeat(bytesToAdd);
-  const payload = redstoneProtocol.RedstonePayload.prepare(packages, newUnsignedMetadata);
-  let timestamp = 0;
-  for (const p of packages) {
-    const newTimestamp = p.dataPackage.timestampMilliseconds / 1e3;
-    if (timestamp === 0) {
-      timestamp = newTimestamp;
-    } else if (timestamp !== newTimestamp) {
-      throw new Error("Timestamps are not equal");
+  /**
+   * Tries to convert amount of token into underlying of current market
+   * @param token
+   * @param amount
+   * @param reserve
+   * @returns
+   */
+  convertToUnderlying(token, amount, reserve = false) {
+    return this.convert(token, this.underlying, amount, reserve);
+  }
+  /**
+   * Tries to convert amount of from one token to another, using latest known prices
+   * @param from
+   * @param to
+   * @param amount
+   * @param reserve
+   */
+  convert(from, to, amount, reserve = false) {
+    if (from === to) {
+      return amount;
     }
+    const fromPrice = reserve ? this.reservePrices.mustGet(from) : this.mainPrices.mustGet(from);
+    const fromScale = 10n ** BigInt(this.sdk.marketRegister.tokensMeta.mustGet(from).decimals);
+    const toPrice = reserve ? this.reservePrices.mustGet(to) : this.mainPrices.mustGet(to);
+    const toScale = 10n ** BigInt(this.sdk.marketRegister.tokensMeta.mustGet(to).decimals);
+    return amount * fromPrice * toScale / (toPrice * fromScale);
   }
-  return {
-    dataFeedId,
-    data: viem.encodeAbiParameters(
-      [{ type: "uint256" }, { type: "bytes" }],
-      [BigInt(timestamp), `0x${payload}`]
-    ),
-    timestamp
-  };
-}
-
-// src/sdk/market/pricefeeds/WstETHPriceFeed.ts
-var WstETHPriceFeedContract = class extends AbstractLPPriceFeedContract {
-  constructor(sdk, args) {
-    super(sdk, {
-      ...args,
-      name: "WstETHPriceFeed",
-      abi: wstEthPriceFeedAbi
+  /**
+   * Loads new prices for this oracle from PriceFeedCompressor
+   * Does not update price feeds, only updates prices
+   */
+  async updatePrices() {
+    const { txs } = await this.updatePriceFeeds();
+    const resp = await simulateMulticall(this.provider.publicClient, {
+      contracts: [
+        ...txs.map(rawTxToMulticallPriceUpdate),
+        {
+          abi: iPriceFeedCompressorAbi,
+          address: this.sdk.addressProvider.getLatestVersion(
+            AP_PRICE_FEED_COMPRESSOR
+          ),
+          functionName: "getPriceFeeds",
+          args: [this.address]
+        }
+      ],
+      allowFailure: false,
+      gas: 550000000n,
+      batchSize: 0
+      // we cannot have price updates and compressor request in different batches
     });
-  }
-  get state() {
-    return {
-      ...this.contractData,
-      contractType: this.priceFeedType,
-      skipCheck: true,
-      pricefeeds: [this.underlyingPriceFeeds[0].state]
-    };
-  }
-  async getValue() {
-    return await this.sdk.provider.publicClient.readContract({
-      abi: iwstEthAbi,
-      address: this.lpContract,
-      functionName: "stEthPerToken"
+    const [entries, tree] = resp.pop();
+    entries.forEach(({ token, priceFeed, reserve }) => {
+      const price = tree.find((n) => n.baseParams.addr === priceFeed)?.answer?.price;
+      if (reserve && price) {
+        this.reservePrices.upsert(token, price);
+      } else if (price) {
+        this.mainPrices.upsert(token, price);
+      }
     });
   }
-};
-
-// src/sdk/market/pricefeeds/YearnPriceFeed.ts
-var YearnPriceFeedContract = class extends AbstractLPPriceFeedContract {
-  constructor(sdk, args) {
-    super(sdk, {
-      ...args,
-      name: "YearnPriceFeed",
-      abi: yearnPriceFeedAbi
+  #labelPriceFeed(address, usage, token) {
+    this.sdk.provider.addressLabels.set(address, (label) => {
+      const { symbol } = this.sdk.marketRegister.tokensMeta.mustGet(token);
+      let pricefeedTag = `${symbol}.${usage}`;
+      if (label) {
+        pricefeedTag = `${label}, ${pricefeedTag}`;
+      }
+      return pricefeedTag;
     });
   }
+  /**
+   * Helper method to find "attachment point" of price feed (makes sense for updatable price feeds only) - token (in v3.0 can be ticker) and main/reserve flag
+   *
+   * @param priceFeed
+   * @returns
+   */
+  #findTokenForPriceFeed(priceFeed) {
+    for (const [token, pf] of Object.entries(this.mainPriceFeeds)) {
+      if (pf.address === priceFeed) {
+        return [token, false];
+      }
+    }
+    for (const [token, pf] of Object.entries(this.reservePriceFeeds)) {
+      if (pf.address === priceFeed) {
+        return [token, true];
+      }
+    }
+    const ticker = priceFeedToTicker[this.sdk.provider.networkType][priceFeed];
+    if (ticker) {
+      return [ticker, false];
+    }
+    throw new Error(`cannot find token for price feed ${priceFeed}`);
+  }
   get state() {
     return {
-      ...this.contractData,
-      contractType: this.priceFeedType,
-      skipCheck: true,
-      pricefeeds: [this.underlyingPriceFeeds[0].state]
+      priceOracleV3: this.contractData,
+      mainPriceFeeds: Object.fromEntries(
+        Object.entries(this.mainPriceFeeds).map(([token, v]) => [
+          token,
+          v.state
+        ])
+      ),
+      reservePriceFeeds: Object.fromEntries(
+        Object.entries(this.reservePriceFeeds).map(([token, v]) => [
+          token,
+          v.state
+        ])
+      )
     };
   }
-  async getValue() {
-    return await this.sdk.provider.publicClient.readContract({
-      abi: iyVaultAbi,
-      address: this.lpContract,
-      functionName: "pricePerShare"
-    });
-  }
+};
+var priceFeedToTicker = {
+  Mainnet: {
+    "0x6F13996411743d22566176482B6b677Ec4eb6cE6": "0x8C23b9E4CB9884e807294c4b4C33820333cC613c",
+    "0xa7cB34Cd731486F61cfDb7ff5F6fC7B40537eD76": "0xFb56Fb16B4F33A875b01881Da7458E09D286208e",
+    "0xcf1FDc8DC6e83B38729d58C117BE704bb2AC362a": "0xf08D818be34C82cB5e3f33AC78F8268828764F17",
+    "0xE683362b8ebcbfd9332CBB79BfAF9fC42073C49b": "0xBdb778F566b6cEd70D3d329DD1D14E221fFe1ba5",
+    "0xB72A69e2182bE87bda706B7Ff9A539AC78338C61": "0x7fF63E75F48aad6F4bE97E75C6421f348f19fE7F",
+    "0xd7396fA3aFB9833293Ce2149EEb3Dbf5380B1e0D": "0xB0EA0EC3Fd4947348816f76768b3a56249d47EEc"
+  },
+  Arbitrum: {
+    "0xcB44ADd611f75F03191f8f1A2e2AF7a0113eadd1": "0x07299E4E806e4253727084c0493fFDf6fB2dBa3D",
+    "0x354A63F07A5c1605920794aFFF09963b6DF897a9": "0x15094B05e679c9B7fDde6FB8e6BDa930ff1D6a62"
+  },
+  Optimism: {
+    "0xF23C91b1E3B7FD9174c82F7Fb2BD270C3CfcC3CE": "0x658f8e60c57ad62a9299ef6c7b1da9a0d1d1e681"
+  },
+  Base: {}
 };
 
-// src/sdk/market/pricefeeds/ZeroPriceFeed.ts
-var ZeroPriceFeedContract = class extends AbstractPriceFeedContract {
-  constructor(sdk, args) {
-    super(sdk, {
-      ...args,
-      name: "ZeroPriceFeed",
-      abi: zeroPriceFeedAbi,
-      decimals: 8
-    });
+// src/sdk/market/MarketFactory.ts
+var MarketFactory = class {
+  riskCurator;
+  poolFactory;
+  priceOracle;
+  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,
+      marketData.pool.underlying
+    );
   }
   get state() {
     return {
-      ...this.contractData,
-      contractType: "PF_ZERO_ORACLE",
-      skipCheck: true,
-      stalenessPeriod: 0,
-      pricefeeds: []
+      pool: this.poolFactory.state,
+      creditManagers: this.creditManagers.map((cm) => cm.state),
+      priceOracle: this.priceOracle.state
     };
   }
 };
 
-// src/sdk/market/pricefeeds/PriceFeedsRegister.ts
-var PriceFeedRegister = class extends SDKConstruct {
-  logger;
-  #hooks = new Hooks();
-  #feeds = new AddressMap();
-  #redstoneUpdater;
-  // public readonly zeroPriceFeed: ZeroPriceFeedContract;
-  constructor(sdk) {
-    super(sdk);
-    this.logger = childLogger("PriceFeedRegister", sdk.logger);
-    this.#redstoneUpdater = new RedstoneUpdater(sdk);
-  }
-  addHook = this.#hooks.addHook.bind(this.#hooks);
-  removeHook = this.#hooks.removeHook.bind(this.#hooks);
+// src/sdk/market/MarketRegister.ts
+var MarketRegister = class {
+  #logger;
   /**
-   * Returns RawTxs to update price feeds
-   * @param priceFeeds top-level price feeds, actual updatable price feeds will be derived. If not provided will use all price feeds that are attached
-   * @returns
+   * Mapping pool.name -> MarketFactory
    */
-  async generatePriceFeedsUpdateTxs(priceFeeds) {
-    const priceFeedz = priceFeeds ?? Object.values(this.#feeds);
-    const updateables = priceFeedz.flatMap((pf) => pf.updatableDependencies());
-    const txs = [];
-    const redstonePFs = [];
-    for (const pf of updateables) {
-      if (pf instanceof RedstonePriceFeedContract) {
-        redstonePFs.push(pf);
-      }
-    }
-    let maxTimestamp = 0;
-    if (redstonePFs.length > 0) {
-      const redstoneUpdates = await this.#redstoneUpdater.getUpdateTxs(redstonePFs);
-      for (const { tx, timestamp } of redstoneUpdates) {
-        if (timestamp > maxTimestamp) {
-          maxTimestamp = timestamp;
+  #markets = {};
+  /**
+   * Token metadata such as symbol and decimals, common across all markets
+   */
+  tokensMeta = new AddressMap();
+  #sdk;
+  constructor(sdk) {
+    this.#sdk = sdk;
+    this.#logger = childLogger("MarketRegister", sdk.logger);
+  }
+  async loadMarkets(curators) {
+    this.#logger?.debug("loading markets");
+    const marketCompressorAddress = this.#sdk.addressProvider.getAddress(
+      AP_MARKET_COMPRESSOR,
+      310
+    );
+    const markets = await this.#sdk.provider.publicClient.readContract({
+      address: marketCompressorAddress,
+      abi: iMarketCompressorAbi,
+      functionName: "getMarkets",
+      args: [
+        {
+          curators,
+          pools: [],
+          underlying: ADDRESS_0X0
         }
-        txs.push(tx);
-      }
+      ],
+      // It's passed as ...rest in viem readContract action, but this might change
+      // @ts-ignore
+      gas: 500000000n
+    });
+    for (const data of markets) {
+      this.#markets[data.pool.name] = new MarketFactory(this.#sdk, data);
     }
-    const result = { txs, timestamp: maxTimestamp };
-    await this.#hooks.triggerHooks("updatesGenerated", result);
-    return result;
+    this.#logger?.info(`loaded ${markets.length} markets`);
   }
-  get(address) {
-    return this.#feeds.get(address);
+  get state() {
+    return Object.values(this.#markets).map((market) => market.state);
   }
-  mustGet(address) {
-    return this.#feeds.mustGet(address);
+  get poolState() {
+    return Object.values(this.#markets).map((market) => market.poolFactory.state);
   }
-  create(data) {
-    const feed = this.#create(data);
-    this.#feeds.upsert(data.baseParams.addr, feed);
-    return feed;
+  get creditManagerState() {
+    return Object.values(this.#markets).flatMap(
+      (market) => market.creditManagers.map((cm) => cm.state)
+    );
   }
-  /**
-   * Set redstone historical timestamp
-   * @param timestampMs in milliseconds
-   */
-  setRedstoneHistoricalTimestamp(timestampMs) {
-    this.#redstoneUpdater.setHistoricalTimestamp(timestampMs);
+  getPoolFactories() {
+    return this.markets.map((market) => market.poolFactory);
+  }
+  get creditManagers() {
+    return this.markets.flatMap((market) => market.creditManagers);
+  }
+  findCreditManager(creditManager) {
+    for (const market of this.markets) {
+      for (const cm of market.creditManagers) {
+        if (cm.creditManager.address === creditManager) {
+          return cm;
+        }
+      }
+    }
+    throw new Error(`cannot find credit manager ${creditManager}`);
   }
-  #create(data) {
-    const contractType = bytes32ToString(
-      data.baseParams.contractType
+  findByCreditManager(creditManager) {
+    const market = Object.values(this.#markets).find(
+      (m) => m.creditManagers.some(
+        (cm) => cm.creditManager.address.toLowerCase() === creditManager.toLowerCase()
+      )
     );
-    switch (contractType) {
-      case "PF_CHAINLINK_ORACLE":
-        return new ChainlinkPriceFeedContract(this.sdk, data);
-      case "PF_YEARN_ORACLE":
-        return new YearnPriceFeedContract(this.sdk, data);
-      case "PF_CURVE_STABLE_LP_ORACLE":
-        return new CurveStablePriceFeedContract(this.sdk, data);
-      case "PF_WSTETH_ORACLE":
-        return new WstETHPriceFeedContract(this.sdk, data);
-      case "PF_BOUNDED_ORACLE":
-        return new BoundedPriceFeedContract(this.sdk, data);
-      case "PF_COMPOSITE_ORACLE":
-        return new CompositePriceFeedContract(this.sdk, data);
-      case "PF_BALANCER_STABLE_LP_ORACLE":
-        return new BalancerStablePriceFeedContract(this.sdk, data);
-      case "PF_BALANCER_WEIGHTED_LP_ORACLE":
-        return new BalancerWeightedPriceFeedContract(this.sdk, data);
-      case "PF_CURVE_CRYPTO_LP_ORACLE":
-        return new CurveCryptoPriceFeedContract(this.sdk, data);
-      case "PF_REDSTONE_ORACLE":
-        return new RedstonePriceFeedContract(this.sdk, data);
-      case "PF_ERC4626_ORACLE":
-        return new Erc4626PriceFeedContract(this.sdk, data);
-      case "PF_CURVE_USD_ORACLE":
-        return new CurveUSDPriceFeedContract(this.sdk, data);
-      case "PF_ZERO_ORACLE":
-        return new ZeroPriceFeedContract(this.sdk, data);
-      case "PF_MELLOW_LRT_ORACLE":
-        return new MellowLRTPriceFeedContract(this.sdk, data);
-      default:
-        throw new Error(`Price feed type ${contractType} not supported, `);
+    if (!market) {
+      throw new Error(`cannot find market for credit manager ${creditManager}`);
     }
+    return market;
+  }
+  get markets() {
+    return Object.values(this.#markets);
+  }
+  async tvl() {
+    const creditManagers = this.creditManagers;
+    const tvls = await Promise.all(creditManagers.map((cm) => cm.tvl()));
+    return tvls.reduce(
+      (acc, curr) => {
+        acc.tvl += curr.tvl;
+        acc.tvlUSD += curr.tvlUSD;
+        return acc;
+      },
+      { tvl: 0n, tvlUSD: 0n }
+    );
   }
 };
 
-// src/sdk/market/PriceOracleContract.ts
-var PriceOracleContract = class extends BaseContract {
-  /**
-   * Underlying token of market to which this price oracle belongs
-   */
-  underlying;
-  /**
-   * Mapping Token => [PriceFeed Address, stalenessPeriod]
-   */
-  mainPriceFeeds = {};
+// src/sdk/accounts/CreditAccountsService.ts
+var CreditAccountsService = class extends SDKConstruct {
+  #compressor;
+  constructor(sdk) {
+    super(sdk);
+    this.#compressor = sdk.addressProvider.getLatestVersion(
+      AP_CREDIT_ACCOUNT_COMPRESSOR
+    );
+  }
   /**
-   * Mapping Token => [PriceFeed Address, stalenessPeriod]
+   * Returns single credit account data, or undefined if it's not found
+   * Performs all necessary price feed updates under the hood
+   * @param account
+   * @returns
    */
-  reservePriceFeeds = {};
+  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.provider.publicClient, {
+      account: this.provider.account,
+      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;
+  }
   /**
-   * Mapping Token => Price in underlying
+   * 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 returned credit accounts are sorted by health factor in ascending order
    */
-  mainPrices = new AddressMap();
+  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(
+          [arg0, { ...caFilter, reverting }, offset],
+          priceUpdateTxs
+        );
+        allCAs.push(...accounts);
+        offset = newOffset;
+      } while (offset !== 0n);
+    }
+    return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
+  }
   /**
-   * Mapping Token => Price in underlying
+   * Generates transaction to liquidate credit account
+   * @param account
+   * @param to Address to transfer underlying left after liquidation
+   * @param slippage
+   * @returns
    */
-  reservePrices = new AddressMap();
-  #priceFeedTree;
-  constructor(sdk, data, underlying) {
-    super(sdk, {
-      ...data.baseParams,
-      name: "PriceOracleV3",
-      abi: priceOracleV3Abi
-    });
-    this.underlying = underlying;
-    const { priceFeedMapping, priceFeedStructure } = data;
-    this.#priceFeedTree = priceFeedStructure;
-    for (const node of priceFeedStructure) {
-      sdk.priceFeeds.create(node);
+  async fullyLiquidate(account, to, slippage = 50n) {
+    const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
+    const preview = await this.sdk.router.findBestClosePath(
+      account,
+      cm.creditManager,
+      slippage
+    );
+    const priceUpdates = await this.getPriceUpdatesForFacade(account);
+    const recipient = to ?? this.sdk.provider.account;
+    if (!recipient) {
+      throw new Error("liquidate account: assets recipient not specied");
     }
-    priceFeedMapping.forEach((node) => {
-      const { token, priceFeed, reserve, stalenessPeriod } = node;
-      const ref = new PriceFeedRef(sdk, priceFeed, stalenessPeriod);
-      const price = this.#priceFeedTree.find(
-        (n) => n.baseParams.addr === priceFeed
-      )?.answer?.price;
-      if (reserve) {
-        this.reservePriceFeeds[token] = ref;
-        if (price) {
-          this.reservePrices.upsert(token, price);
-        }
-      } else {
-        this.mainPriceFeeds[token] = ref;
-        if (price) {
-          this.mainPrices.upsert(token, price);
-        }
-      }
-      this.#labelPriceFeed(priceFeed, reserve ? "Reserve" : "Main", token);
+    return cm.creditFacade.createRawTx({
+      functionName: "liquidateCreditAccount",
+      args: [
+        account.creditAccount,
+        recipient,
+        [...priceUpdates, ...preview.calls]
+      ],
+      description: `fully liquidate ${account.creditAccount}`
     });
-    this.logger?.debug(
-      `Got ${Object.keys(this.mainPriceFeeds).length} main and ${Object.keys(this.reservePriceFeeds).length} reserve price feeds`
-    );
   }
   /**
-   * Returns main and reserve price feeds for given tokens
-   * @param tokens
-   * @param opts Option to include main/reserve feeds only, defaults to both
+   * 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
    */
-  priceFeedsForTokens(tokens, opts) {
-    const main = opts?.main ?? true;
-    const reserve = opts?.reserve ?? true;
-    return tokens.flatMap((t) => [
-      main ? this.mainPriceFeeds[t].priceFeed : void 0,
-      reserve ? this.reservePriceFeeds[t].priceFeed : void 0
-    ]).filter((f) => !!f);
+  async closeCreditAccount(operation, ca, assetsToKeep, to, slippage = 50n) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const recipient = to ?? this.sdk.provider.account;
+    if (!recipient) {
+      throw new Error("close account: assets recipient not specied");
+    }
+    const calls = await this.#prepareCloseCreditAccount(
+      ca,
+      cm,
+      assetsToKeep,
+      recipient,
+      slippage
+    );
+    return cm.creditFacade.createRawTx({
+      functionName: operation === "close" ? "closeCreditAccount" : "multicall",
+      args: [ca.creditAccount, calls],
+      description: `${operation} account ${ca.creditAccount}`
+    });
   }
   /**
-   * Generates updates for all updateable price feeds in this oracle (including dependencies)
+   * Internal wrapper for CreditAccountCompressor.getCreditAccounts + price updates wrapped into multicall
+   * @param args
+   * @param priceUpdateTxs
    * @returns
    */
-  async updatePriceFeeds() {
-    const updatables = [];
-    for (const node of this.#priceFeedTree) {
-      if (node.updatable) {
-        updatables.push(this.sdk.priceFeeds.mustGet(node.baseParams.addr));
-      }
+  async #getCreditAccounts(args, priceUpdateTxs) {
+    if (priceUpdateTxs?.length) {
+      const resp = await simulateMulticall(this.provider.publicClient, {
+        account: this.provider.account,
+        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.sdk.priceFeeds.generatePriceFeedsUpdateTxs(updatables);
+    return this.provider.publicClient.readContract({
+      abi: iCreditAccountCompressorAbi,
+      address: this.#compressor,
+      functionName: "getCreditAccounts",
+      args
+    });
   }
   /**
-   * Converts previously obtained price updates into CreditFacade multicall entries
-   * @param creditFacade
-   * @param updates
+   * Returns raw txs that are needed to update all price feeds so that all credit accounts (possibly from different markets) compute
+   * @param accounts
    * @returns
    */
-  onDemandPriceUpdates(updates) {
-    const result = [];
-    if (!updates) {
-      return result;
+  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 { txs } = updates;
-    for (const tx of txs) {
-      const { to: priceFeed, callData } = tx;
-      const [token, reserve] = this.#findTokenForPriceFeed(priceFeed);
-      const { args } = viem.decodeFunctionData({
-        abi: iUpdatablePriceFeedAbi,
-        data: callData
-      });
-      const data = args[0];
-      result.push({
-        token,
-        reserve,
-        data
-      });
+    const priceFeeds = [];
+    for (const [pool, priceFeedFactory] of oracleByPool.entries()) {
+      const tokens = Array.from(tokensByPool.get(pool) ?? []);
+      priceFeeds.push(...priceFeedFactory.priceFeedsForTokens(tokens));
     }
-    return result;
+    return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(priceFeeds);
   }
   /**
-   * Tries to convert amount of token into underlying of current market
-   * @param token
-   * @param amount
-   * @param reserve
+   * Returns account price updates in a non-encoded format
+   * @param acc
    * @returns
    */
-  convertToUnderlying(token, amount, reserve = false) {
-    return this.convert(token, this.underlying, amount, reserve);
+  async getOnDemandPriceUpdates(acc) {
+    const market = this.sdk.marketRegister.findByCreditManager(
+      acc.creditManager
+    );
+    const update = await this.getUpdateForAccounts([acc]);
+    return market.priceOracle.onDemandPriceUpdates(update);
   }
   /**
-   * Tries to convert amount of from one token to another, using latest known prices
-   * @param from
-   * @param to
-   * @param amount
-   * @param reserve
+   * Returns price updates in format that is accepted by various credit facade methods (multicall, close/liquidate, etc...)
+   * @param acc
+   * @returns
    */
-  convert(from, to, amount, reserve = false) {
-    if (from === to) {
-      return amount;
+  async getPriceUpdatesForFacade(acc) {
+    const cm = this.sdk.marketRegister.findCreditManager(acc.creditManager);
+    const updates = await this.getOnDemandPriceUpdates(acc);
+    return updates.map(({ token, reserve, data }) => ({
+      target: cm.creditFacade.address,
+      callData: viem.encodeFunctionData({
+        abi: iCreditFacadeV3MulticallAbi,
+        functionName: "onDemandPriceUpdate",
+        args: [token, reserve, data]
+      })
+    }));
+  }
+  async #prepareCloseCreditAccount(ca, cm, assetsToKeep, to, slippage = 50n) {
+    const closePath = await this.sdk.router.findBestClosePath(
+      ca,
+      cm.creditManager,
+      slippage
+    );
+    const priceUpdates = await this.getPriceUpdatesForFacade(ca);
+    return [
+      ...priceUpdates,
+      ...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]
+          })
+        });
+      }
     }
-    const fromPrice = reserve ? this.reservePrices.mustGet(from) : this.mainPrices.mustGet(from);
-    const fromScale = 10n ** BigInt(this.sdk.marketRegister.tokensMeta.mustGet(from).decimals);
-    const toPrice = reserve ? this.reservePrices.mustGet(to) : this.mainPrices.mustGet(to);
-    const toScale = 10n ** BigInt(this.sdk.marketRegister.tokensMeta.mustGet(to).decimals);
-    return amount * fromPrice * toScale / (toPrice * fromScale);
+    return calls;
   }
-  // async loadPrices(
-  //   priceUpdatesTxs: Array<RawTx>,
-  //   block: bigint,
-  // ): Promise<{
-  //   mainPrices: Record<Address, bigint>;
-  //   reservePrices: Record<Address, bigint>;
-  // }> {
-  //   const priceUpdateCalls: Array<MultiCallStruct> = priceUpdatesTxs.map(
-  //     tx => ({
-  //       target: tx.to,
-  //       callData: tx.callData,
-  //       allowFailure: false,
-  //     }),
-  //   );
-  //   const getPricesRawCalls = (reserve: boolean): Array<MultiCallStruct> => {
-  //     return Object.keys(
-  //       reserve ? this.reservePriceFeeds : this.mainPriceFeeds,
-  //     ).map(token => ({
-  //       target: this.address,
-  //       callData: encodeFunctionData({
-  //         functionName: "getPriceRaw",
-  //         args: [token as Address, reserve],
-  //         abi: this.abi,
-  //       }),
-  //       allowFailure: true,
-  //     }));
-  //   };
-  //   const { result } = await this.v3.publicClient.simulateContract({
-  //     address: MULTICALL_ADDRESS,
-  //     abi: multicall3Abi,
-  //     functionName: "aggregate3",
-  //     args: [
-  //       [
-  //         ...priceUpdateCalls,
-  //         ...getPricesRawCalls(false),
-  //         ...getPricesRawCalls(true),
-  //       ],
-  //     ],
-  //     chain: this.v3.publicClient.chain!,
-  //     account: this.v3.walletClient.account!,
-  //     gas: 550_000_000n,
-  //     // blockNumber: BigInt(block),
-  //   });
-  //   const returnRawPrices = (
-  //     result as Array<{ success: boolean; returnData: Hex }>
-  //   ).slice(priceUpdateCalls.length);
-  //   const prices = returnRawPrices.map(callReturn =>
-  //     callReturn.success
-  //       ? decodeFunctionResult({
-  //           functionName: "getPrice",
-  //           abi: this.abi,
-  //           data: callReturn.returnData! as Hex,
-  //         })
-  //       : 0n,
-  //   ) as Array<bigint>;
-  //   const mainPrices: Record<Address, bigint> = {};
-  //   const reservePrices: Record<Address, bigint> = {};
-  //   const mainPFlength = Object.keys(this.mainPriceFeeds).length;
-  //   prices.forEach((price, i) => {
-  //     if (i < mainPFlength) {
-  //       mainPrices[Object.keys(this.mainPriceFeeds)[i] as Address] = price;
-  //     } else {
-  //       reservePrices[
-  //         Object.keys(this.reservePriceFeeds)[i - mainPFlength] as Address
-  //       ] = price;
-  //     }
-  //   });
-  //   return { mainPrices, reservePrices };
-  // }
-  #labelPriceFeed(address, usage, token) {
-    this.sdk.provider.addressLabels.set(address, (label) => {
-      const { symbol } = this.sdk.marketRegister.tokensMeta.mustGet(token);
-      let pricefeedTag = `${symbol}.${usage}`;
-      if (label) {
-        pricefeedTag = `${label}, ${pricefeedTag}`;
+  #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 pricefeedTag;
-    });
+    }
+    return calls;
+  }
+  #prepareWithdrawToken(ca, token, amount, to) {
+    return {
+      target: ca.creditFacade,
+      callData: viem.encodeFunctionData({
+        abi: iCreditFacadeV3MulticallAbi,
+        functionName: "withdrawCollateral",
+        args: [token, amount, to]
+      })
+    };
   }
   /**
-   * Helper method to find "attachment point" of price feed (makes sense for updatable price feeds only) - token (in v3.0 can be ticker) and main/reserve flag
-   *
-   * @param priceFeed
-   * @returns
+   * Returns addresses of pools of attached markets
    */
-  #findTokenForPriceFeed(priceFeed) {
-    for (const [token, pf] of Object.entries(this.mainPriceFeeds)) {
-      if (pf.address === priceFeed) {
-        return [token, false];
+  get pools() {
+    return this.sdk.marketRegister.poolState.map((p) => p.pool.address);
+  }
+};
+var AddressProviderContractV3_1 = class extends BaseContract {
+  #addresses = {};
+  versions = {};
+  latest = {};
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "AddressProviderV3",
+      abi: iAddressProviderV3_1Abi
+    });
+  }
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "setAddress": {
+        if (params.args.length !== 3) {
+          const [key2, saveVersion2] = params.args;
+          return [key2, `${saveVersion2}`];
+        }
+        const [key, value, saveVersion] = params.args;
+        return [viem.bytesToString(viem.toBytes(key)), value, `${saveVersion}`];
       }
+      default:
+        return void 0;
     }
-    for (const [token, pf] of Object.entries(this.reservePriceFeeds)) {
-      if (pf.address === priceFeed) {
-        return [token, true];
-      }
+  }
+  setInternalAddress(key, address, version) {
+    if (!this.#addresses[key]) {
+      this.#addresses[key] = {};
+    }
+    this.#addresses[key][version] = address;
+    if (!this.latest[key] || version > this.latest[key]) {
+      this.latest[key] = version;
     }
-    throw new Error(`cannot find token for price feed ${priceFeed}`);
-  }
-  get state() {
-    return {
-      priceOracleV3: this.contractData,
-      mainPriceFeeds: Object.fromEntries(
-        Object.entries(this.mainPriceFeeds).map(([token, v]) => [
-          token,
-          v.state
-        ])
-      ),
-      reservePriceFeeds: Object.fromEntries(
-        Object.entries(this.reservePriceFeeds).map(([token, v]) => [
-          token,
-          v.state
-        ])
-      )
-    };
+    if (!this.versions[key]) {
+      this.versions[key] = /* @__PURE__ */ new Set();
+    }
+    this.versions[key].add(version);
   }
-};
-
-// src/sdk/market/MarketFactory.ts
-var MarketFactory = class {
-  riskCurator;
-  poolFactory;
-  priceOracle;
-  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);
+  getAddress(contract, version = NO_VERSION) {
+    if (!this.#addresses[contract]) {
+      throw new Error(`Address ${contract}, version: ${version} not found`);
     }
-    this.poolFactory = new PoolFactory(sdk, marketData);
-    for (let i = 0; i < marketData.creditManagers.length; i++) {
-      this.creditManagers.push(new CreditFactory(sdk, marketData, i));
+    const result = this.#addresses[contract][version];
+    if (!result) {
+      throw new Error(`Address ${contract}, version: ${version} not found`);
     }
-    this.priceOracle = new PriceOracleContract(
-      sdk,
-      marketData.priceOracleData,
-      marketData.pool.underlying
+    return result;
+  }
+  getLatestVersion(contract) {
+    if (!this.latest[contract]) {
+      throw new Error(`Latest version for ${contract} not found`);
+    }
+    this.logger?.debug(
+      `Latest version found for ${contract} : ${this.latest[contract]}`
     );
+    return this.getAddress(contract, this.latest[contract]);
+  }
+  async fetchState(toBlock) {
+    const entries = await this.contract.read.getAllSavedContracts({
+      blockNumber: toBlock
+    });
+    entries.forEach((log) => {
+      this.setInternalAddress(log.key, log.value, Number(log.version));
+    });
+    this.version = 310;
   }
   get state() {
     return {
-      pool: this.poolFactory.state,
-      creditManagers: this.creditManagers.map((cm) => cm.state),
-      priceOracle: this.priceOracle.state
+      ...this.contractData,
+      addresses: this.#addresses
     };
   }
+  parseLog(log) {
+    const parsedLog = viem.parseEventLogs({
+      abi: this.abi,
+      logs: [log]
+    })[0];
+    switch (parsedLog.eventName) {
+      case "SetAddress": {
+        const parsedLog2 = viem.parseEventLogs({
+          abi: this.abi,
+          eventName: "SetAddress",
+          logs: [log]
+        })[0];
+        const key = parsedLog2.args.key;
+        this.setInternalAddress(
+          key,
+          parsedLog.args.value,
+          Number(parsedLog2.args.version)
+        );
+        break;
+      }
+      default:
+        this.logger?.warn(`Unknown event: ${parsedLog.eventName}`);
+        break;
+    }
+  }
 };
-
-// src/sdk/market/MarketRegister.ts
-var MarketRegister = class {
-  #logger;
-  /**
-   * Mapping pool.name -> MarketFactory
-   */
-  #markets = {};
-  /**
-   * Token metadata such as symbol and decimals, common across all markets
-   */
-  tokensMeta = new AddressMap();
-  #sdk;
-  constructor(sdk) {
-    this.#sdk = sdk;
-    this.#logger = childLogger("MarketRegister", sdk.logger);
+var BotListContract = class extends BaseContract {
+  approvedCreditManagers = /* @__PURE__ */ new Set();
+  constructor(sdk, address) {
+    super(sdk, { addr: address, name: "BotListV3", abi: botListV3Abi });
   }
-  async loadMarkets(curators) {
-    this.#logger?.debug("loading markets");
-    const marketCompressorAddress = this.#sdk.addressProvider.getAddress(
-      AP_MARKET_COMPRESSOR,
-      310
-    );
-    const markets = await this.#sdk.provider.publicClient.readContract({
-      address: marketCompressorAddress,
-      abi: iMarketCompressorAbi,
-      functionName: "getMarkets",
-      args: [
-        {
-          curators,
-          pools: [],
-          underlying: ADDRESS_0X0
-        }
-      ],
-      // It's passed as ...rest in viem readContract action, but this might change
-      // @ts-ignore
-      gas: 500000000n
-    });
-    for (const data of markets) {
-      this.#markets[data.pool.name] = new MarketFactory(this.#sdk, data);
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "setCreditManagerApprovedStatus": {
+        const [creditManager, status] = params.args;
+        return [this.addressLabels.get(creditManager), `${status}`];
+      }
+      case "setBotSpecialPermissions": {
+        const [bot, creditManager, permissions] = params.args;
+        return [
+          this.addressLabels.get(bot),
+          this.addressLabels.get(creditManager),
+          botPermissionsToString(permissions)
+        ];
+      }
+      default:
+        return void 0;
     }
-    this.#logger?.info(`loaded ${markets.length} markets`);
   }
-  get state() {
-    return Object.values(this.#markets).map((market) => market.state);
-  }
-  get poolState() {
-    return Object.values(this.#markets).map((market) => market.poolFactory.state);
+  async fetchState(toBlock) {
+    const logs = await this.provider.publicClient.getContractEvents({
+      address: this.address,
+      abi: this.abi,
+      fromBlock: 0n,
+      toBlock
+    });
+    logs.forEach((e) => this.parseLog(e));
   }
-  get creditManagerState() {
-    return Object.values(this.#markets).flatMap(
-      (market) => market.creditManagers.map((cm) => cm.state)
-    );
+  parseLog(log) {
+    const parsedLog = viem.parseEventLogs({
+      abi: this.abi,
+      logs: [log]
+    })[0];
+    switch (parsedLog.eventName) {
+      case "SetCreditManagerApprovedStatus":
+        if (parsedLog.args.approved) {
+          this.approvedCreditManagers.add(parsedLog.args.creditManager);
+        } else {
+          this.approvedCreditManagers.delete(parsedLog.args.creditManager);
+        }
+        break;
+      case "SetBotSpecialPermissions":
+        this.logger?.debug(
+          `Bot ${parsedLog.args.bot} has been given permissions ${botPermissionsToString(
+            parsedLog.args.permissions
+          )} for credit manager ${parsedLog.args.creditManager}`
+        );
+        break;
+      default:
+        this.logger?.warn(`Unknown event: ${parsedLog.eventName}`);
+        break;
+    }
   }
-  getPoolFactories() {
-    return this.markets.map((market) => market.poolFactory);
+  get state() {
+    return {
+      ...this.contractData
+    };
   }
-  get creditManagers() {
-    return this.markets.flatMap((market) => market.creditManagers);
+};
+
+// src/sdk/core/GearStakingV3Contract.ts
+var GearStakingContract = class extends BaseContract {
+  constructor(sdk, address) {
+    super(sdk, { addr: address, name: "GearStakingV3", abi: gearStakingV3Abi });
   }
-  findCreditManager(creditManager) {
-    for (const market of this.markets) {
-      for (const cm of market.creditManagers) {
-        if (cm.creditManager.address === creditManager) {
-          return cm;
-        }
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "setVotingContractStatus": {
+        const [address, status] = params.args;
+        return [this.addressLabels.get(address), VotingContractStatus[status]];
       }
+      default:
+        return void 0;
     }
-    throw new Error(`cannot find credit manager ${creditManager}`);
-  }
-  findByCreditManager(creditManager) {
-    const market = Object.values(this.#markets).find(
-      (m) => m.creditManagers.some(
-        (cm) => cm.creditManager.address.toLowerCase() === creditManager.toLowerCase()
-      )
-    );
-    if (!market) {
-      throw new Error(`cannot find market for credit manager ${creditManager}`);
-    }
-    return market;
   }
-  get markets() {
-    return Object.values(this.#markets);
-  }
-  async tvl() {
-    const creditManagers = this.creditManagers;
-    const tvls = await Promise.all(creditManagers.map((cm) => cm.tvl()));
-    return tvls.reduce(
-      (acc, curr) => {
-        acc.tvl += curr.tvl;
-        acc.tvlUSD += curr.tvlUSD;
-        return acc;
-      },
-      { tvl: 0n, tvlUSD: 0n }
-    );
+  get state() {
+    return {
+      ...this.contractData,
+      successor: ADDRESS_0X0,
+      migrator: ADDRESS_0X0
+    };
   }
 };
 var PathOptionFactory = class _PathOptionFactory {
@@ -20809,6 +21029,7 @@ exports.AP_INSOLVENCY_CHECKER = AP_INSOLVENCY_CHECKER;
 exports.AP_MARKET_COMPRESSOR = AP_MARKET_COMPRESSOR;
 exports.AP_MULTI_PAUSE = AP_MULTI_PAUSE;
 exports.AP_PARTIAL_LIQUIDATION_BOT = AP_PARTIAL_LIQUIDATION_BOT;
+exports.AP_PRICE_FEED_COMPRESSOR = AP_PRICE_FEED_COMPRESSOR;
 exports.AP_PRICE_ORACLE = AP_PRICE_ORACLE;
 exports.AP_ROUTER = AP_ROUTER;
 exports.AP_TREASURY = AP_TREASURY;
@@ -20908,5 +21129,6 @@ exports.json_parse = json_parse;
 exports.json_stringify = json_stringify;
 exports.numberWithCommas = numberWithCommas;
 exports.percentFmt = percentFmt;
+exports.rawTxToMulticallPriceUpdate = rawTxToMulticallPriceUpdate;
 exports.simulateMulticall = simulateMulticall;
 exports.toHumanFormat = toHumanFormat;