@gearbox-protocol/sdk 12.4.0 → 12.6.0-next.1

package/dist/esm/sdk/core/address-provider/AddressProviderV310Contract.js

@@ -3,7 +3,7 @@ import { iAddressProviderV310Abi } from "../../../abi/310/generated.js";
 import AbstractAddressProviderContract from "./AbstractAddressProviderContract.js";
 const abi = iAddressProviderV310Abi;
 class AddressProviderV310Contract extends AbstractAddressProviderContract {
-  constructor(options, address, version = 310, addresses = {}) {
+  constructor(options, address, version = 310, addresses) {
     super(
       options,
       {

package/dist/esm/sdk/core/address-provider/createAddressProvider.js

@@ -1,12 +1,26 @@
 import { iVersionAbi } from "../../../abi/iVersion.js";
 import {
   ADDRESS_PROVIDER_V310,
+  AP_MARKET_COMPRESSOR,
+  AP_PRICE_FEED_COMPRESSOR,
   isV300,
   isV310
 } from "../../constants/index.js";
 import { hexEq } from "../../utils/hex.js";
 import { AddressProviderV300Contract } from "./AddressProviderV300Contract.js";
 import { AddressProviderV310Contract } from "./AddressProviderV310Contract.js";
+const OVERRIDE_ADDRESSES = {
+  // Override price feed compressor and market feed compressor
+  // we urgently deployed fix and it has not been added to the address provider yet
+  Mainnet: {
+    [AP_PRICE_FEED_COMPRESSOR]: {
+      311: "0x1fA2637B9fab0CD14290A7EE908DDc9688a15120"
+    },
+    [AP_MARKET_COMPRESSOR]: {
+      311: "0x0C27F242f6e9F2A9AD3261bE6e439De3B948bcA2"
+    }
+  }
+};
 async function createAddressProvider(sdk, address) {
   let v;
   if (hexEq(address, ADDRESS_PROVIDER_V310)) {
@@ -25,11 +39,15 @@ function hydrateAddressProvider(sdk, state) {
   return newAddressProvider(sdk, addr, Number(version), state.addresses);
 }
 function newAddressProvider(sdk, address, version, addresses) {
+  const addrOptions = {
+    addresses,
+    overrides: OVERRIDE_ADDRESSES[sdk.networkType]
+  };
   if (isV300(version)) {
-    return new AddressProviderV300Contract(sdk, address, version, addresses);
+    return new AddressProviderV300Contract(sdk, address, version, addrOptions);
   }
   if (isV310(version)) {
-    return new AddressProviderV310Contract(sdk, address, version, addresses);
+    return new AddressProviderV310Contract(sdk, address, version, addrOptions);
   }
   throw new Error(`unsupported address provider version: ${version}`);
 }

package/dist/esm/sdk/market/pricefeeds/updates/PythUpdater.js

@@ -1,15 +1,8 @@
-import { Buffer } from "buffer";
-import { encodeAbiParameters, toHex } from "viem";
 import { z } from "zod/v4";
 import { SDKConstruct } from "../../../base/index.js";
-import { retry } from "../../../utils/index.js";
+import { fetchPythPayloads } from "./fetchPythPayloads.js";
 import { PriceUpdatesCache } from "./PriceUpdatesCache.js";
 import { PriceUpdateTx } from "./PriceUpdateTx.js";
-import {
-  parseAccumulatorUpdateData,
-  parsePriceFeedMessage,
-  sliceAccumulatorUpdateData
-} from "./PythAccumulatorUpdateData.js";
 class PythUpdateTx extends PriceUpdateTx {
   name = "pyth";
 }
@@ -38,16 +31,15 @@ const PythOptions = z.object({
 class PythUpdater extends SDKConstruct {
   #cache;
   #historicalTimestamp;
-  #api;
+  #apiProxy;
   #ignoreMissingFeeds;
   constructor(sdk, opts = {}) {
     super(sdk);
-    this.#ignoreMissingFeeds = opts.ignoreMissingFeeds;
-    this.#api = opts.apiProxy ?? "https://hermes.pyth.network/v2/updates/price/";
-    this.#api = this.#api.endsWith("/") ? this.#api : `${this.#api}/`;
-    const ts = opts.historicTimestamp;
-    if (ts) {
-      this.#historicalTimestamp = ts === true ? Number(this.sdk.timestamp) : ts;
+    const { apiProxy, cacheTTL, ignoreMissingFeeds, historicTimestamp } = opts;
+    this.#ignoreMissingFeeds = ignoreMissingFeeds;
+    this.#apiProxy = apiProxy;
+    if (historicTimestamp) {
+      this.#historicalTimestamp = historicTimestamp === true ? Number(this.sdk.timestamp) : historicTimestamp;
       this.logger?.debug(
         `using historical timestamp ${this.#historicalTimestamp}`
       );
@@ -56,8 +48,8 @@ class PythUpdater extends SDKConstruct {
       // currently staleness period is 240 seconds on all networks, add some buffer
       // this period of 4 minutes is selected based on time that is required for user to sign transaction with wallet
       // so it's unlikely to decrease
-      ttl: opts.cacheTTL ?? 225 * 1e3,
-      historical: !!ts
+      ttl: cacheTTL ?? 225 * 1e3,
+      historical: !!historicTimestamp
     });
   }
   async getUpdateTxs(feeds) {
@@ -148,72 +140,18 @@ class PythUpdater extends SDKConstruct {
     this.logger?.debug(
       `fetching pyth payloads for ${dataFeedsIds.size} price feeds: ${ids.join(", ")}${tsStr}`
     );
-    const url = new URL(this.#api + (this.#historicalTimestamp ?? "latest"));
-    url.searchParams.append("parsed", "false");
-    if (this.#ignoreMissingFeeds) {
-      url.searchParams.append("ignore_invalid_price_ids", "true");
-    }
-    for (const id of dataFeedsIds) {
-      url.searchParams.append("ids[]", id);
-    }
-    const resp = await retry(
-      async () => {
-        const resp2 = await fetch(url.toString());
-        if (!resp2.ok) {
-          const body = await resp2.text();
-          throw new Error(
-            `failed to fetch pyth payloads: ${resp2.statusText}: ${body}`
-          );
-        }
-        const data = await resp2.json();
-        return data;
-      },
-      { attempts: 3, exponent: 2, interval: 200 }
-    );
-    const result = respToCalldata(resp);
-    if (!this.#ignoreMissingFeeds && result.length !== dataFeedsIds.size) {
-      throw new Error(
-        `expected ${dataFeedsIds.size} price feeds, got ${result.length}`
-      );
-    }
-    return result;
+    return fetchPythPayloads({
+      dataFeedsIds,
+      historicalTimestampSeconds: this.#historicalTimestamp,
+      apiProxy: this.#apiProxy,
+      ignoreMissingFeeds: this.#ignoreMissingFeeds,
+      logger: this.logger
+    });
   }
 }
 function isPyth(pf) {
   return pf.contractType === "PRICE_FEED::PYTH";
 }
-function respToCalldata(resp) {
-  if (resp.binary.data.length === 0) {
-    return [];
-  }
-  const updates = splitAccumulatorUpdates(resp.binary.data[0]);
-  return updates.map(({ data, dataFeedId, timestamp }) => {
-    return {
-      dataFeedId,
-      data: encodeAbiParameters(
-        [{ type: "uint256" }, { type: "bytes[]" }],
-        [BigInt(timestamp), [data]]
-      ),
-      timestamp,
-      cached: false
-    };
-  });
-}
-function splitAccumulatorUpdates(binary) {
-  const data = Buffer.from(binary, "hex");
-  const parsed = parseAccumulatorUpdateData(data);
-  const results = [];
-  for (let i = 0; i < parsed.updates.length; i++) {
-    const upd = parsed.updates[i].message;
-    const msg = parsePriceFeedMessage(upd);
-    results.push({
-      dataFeedId: toHex(msg.feedId),
-      timestamp: msg.publishTime.toNumber(),
-      data: toHex(sliceAccumulatorUpdateData(data, i, i + 1))
-    });
-  }
-  return results;
-}
 export {
   PythOptions,
   PythUpdater

package/dist/esm/sdk/market/pricefeeds/updates/RedstoneUpdater.js

@@ -1,12 +1,7 @@
-import { DataServiceWrapper } from "@redstone-finance/evm-connector";
-import { RedstonePayload } from "@redstone-finance/protocol";
-import {
-  getSignersForDataServiceId
-} from "@redstone-finance/sdk";
-import { encodeAbiParameters, toBytes } from "viem";
 import { z } from "zod/v4";
 import { SDKConstruct } from "../../../base/index.js";
-import { AddressMap, retry } from "../../../utils/index.js";
+import { AddressMap } from "../../../utils/index.js";
+import { fetchRedstonePayloads } from "./fetchRedstonePayloads.js";
 import { PriceUpdatesCache } from "./PriceUpdatesCache.js";
 import { PriceUpdateTx } from "./PriceUpdateTx.js";
 class RedstoneUpdateTx extends PriceUpdateTx {
@@ -222,102 +217,18 @@ class RedstoneUpdater extends SDKConstruct {
     this.logger?.debug(
       `fetching redstone payloads for ${dataFeedsIds.size} data feeds in ${dataServiceId} with ${uniqueSignersCount} signers: ${dataPackagesIds.join(", ")}${tsStr}`
     );
-    const wrapper = new DataServiceWrapper({
+    return fetchRedstonePayloads({
       dataServiceId,
-      dataPackagesIds,
+      dataFeedsIds,
       uniqueSignersCount,
-      authorizedSigners: getSignersForDataServiceId(
-        dataServiceId
-      ),
-      historicalTimestamp: this.#historicalTimestampMs,
-      urls: this.#gateways,
-      ignoreMissingFeed: this.#ignoreMissingFeeds,
-      enableEnhancedLogs: this.#enableLogging
+      historicalTimestampMs: this.#historicalTimestampMs,
+      gateways: this.#gateways,
+      ignoreMissingFeeds: this.#ignoreMissingFeeds,
+      enableLogging: this.#enableLogging,
+      logger: this.logger,
+      metadataTimestampMs: Number(this.sdk.timestamp) * 1e3
     });
-    wrapper.setMetadataTimestamp(
-      this.#historicalTimestampMs ?? Number(this.sdk.timestamp) * 1e3
-    );
-    const dataPayload = await retry(
-      () => wrapper.prepareRedstonePayload(true),
-      { attempts: 5, interval: this.#historicalTimestampMs ? 30500 : 250 }
-    );
-    const parsed = RedstonePayload.parse(toBytes(`0x${dataPayload}`));
-    const packagesByDataFeedId = groupDataPackages(parsed.signedDataPackages);
-    const result = [];
-    for (const dataFeedId of dataFeedsIds) {
-      const signedDataPackages = packagesByDataFeedId[dataFeedId];
-      if (!signedDataPackages) {
-        if (this.#ignoreMissingFeeds) {
-          this.logger?.warn(`cannot find data packages for ${dataFeedId}`);
-          continue;
-        }
-        throw new Error(`cannot find data packages for ${dataFeedId}`);
-      }
-      if (signedDataPackages.length !== uniqueSignersCount) {
-        if (this.#ignoreMissingFeeds) {
-          this.logger?.warn(
-            `got ${signedDataPackages.length} data packages for ${dataFeedId}, but expected ${uniqueSignersCount}`
-          );
-          continue;
-        }
-        throw new Error(
-          `got ${signedDataPackages.length} data packages for ${dataFeedId}, but expected ${uniqueSignersCount}`
-        );
-      }
-      result.push(
-        getCalldataWithTimestamp(
-          dataFeedId,
-          signedDataPackages,
-          wrapper.getUnsignedMetadata()
-        )
-      );
-    }
-    return result;
-  }
-}
-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);
-  }
-  return packagesByDataFeedId;
-}
-function getCalldataWithTimestamp(dataFeedId, packages, unsignedMetadata) {
-  const originalPayload = RedstonePayload.prepare(packages, unsignedMetadata);
-  const originalPayloadLength = originalPayload.length / 2;
-  const bytesToAdd = 32 - originalPayloadLength % 32;
-  const newUnsignedMetadata = unsignedMetadata + "_".repeat(bytesToAdd);
-  const payload = 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: encodeAbiParameters(
-      [{ type: "uint256" }, { type: "bytes" }],
-      [BigInt(timestamp), `0x${payload}`]
-    ),
-    timestamp,
-    cached: false
-  };
 }
 function isRedstone(pf) {
   return pf.contractType === "PRICE_FEED::REDSTONE";

package/dist/esm/sdk/market/pricefeeds/updates/fetchPythPayloads.js

@@ -0,0 +1,91 @@
+import { Buffer } from "buffer";
+import { encodeAbiParameters, toHex } from "viem";
+import { retry } from "../../../utils/index.js";
+import {
+  parseAccumulatorUpdateData,
+  parsePriceFeedMessage,
+  sliceAccumulatorUpdateData
+} from "./PythAccumulatorUpdateData.js";
+async function fetchPythPayloads(options) {
+  const {
+    dataFeedsIds,
+    ignoreMissingFeeds,
+    historicalTimestampSeconds,
+    logger,
+    apiProxy
+  } = options;
+  const ids = Array.from(new Set(dataFeedsIds));
+  if (ids.length === 0) {
+    return [];
+  }
+  let api = apiProxy ?? "https://hermes.pyth.network/v2/updates/price/";
+  api = api.endsWith("/") ? api : `${api}/`;
+  const url = new URL(api + (historicalTimestampSeconds ?? "latest"));
+  url.searchParams.append("parsed", "false");
+  if (ignoreMissingFeeds) {
+    url.searchParams.append("ignore_invalid_price_ids", "true");
+  }
+  for (const id of dataFeedsIds) {
+    url.searchParams.append("ids[]", id);
+  }
+  const resp = await retry(
+    async () => {
+      const resp2 = await fetch(url.toString());
+      if (!resp2.ok) {
+        const body = await resp2.text();
+        throw new Error(
+          `failed to fetch pyth payloads: ${resp2.statusText}: ${body}`
+        );
+      }
+      const data = await resp2.json();
+      return data;
+    },
+    { attempts: 3, exponent: 2, interval: 200 }
+  );
+  const result = respToCalldata(resp);
+  if (result.length !== ids.length) {
+    if (ignoreMissingFeeds) {
+      logger?.warn(`expected ${ids.length} price feeds, got ${result.length}`);
+    } else {
+      throw new Error(
+        `expected ${ids.length} price feeds, got ${result.length}`
+      );
+    }
+  }
+  return result;
+}
+function respToCalldata(resp) {
+  if (resp.binary.data.length === 0) {
+    return [];
+  }
+  const updates = splitAccumulatorUpdates(resp.binary.data[0]);
+  return updates.map(({ data, dataFeedId, timestamp }) => {
+    return {
+      dataFeedId,
+      data: encodeAbiParameters(
+        [{ type: "uint256" }, { type: "bytes[]" }],
+        [BigInt(timestamp), [data]]
+      ),
+      timestamp,
+      cached: false
+    };
+  });
+}
+function splitAccumulatorUpdates(binary) {
+  const data = Buffer.from(binary, "hex");
+  const parsed = parseAccumulatorUpdateData(data);
+  const results = [];
+  for (let i = 0; i < parsed.updates.length; i++) {
+    const upd = parsed.updates[i].message;
+    const msg = parsePriceFeedMessage(upd);
+    results.push({
+      dataFeedId: toHex(msg.feedId),
+      timestamp: msg.publishTime.toNumber(),
+      data: toHex(sliceAccumulatorUpdateData(data, i, i + 1))
+    });
+  }
+  return results;
+}
+export {
+  fetchPythPayloads
+};

package/dist/esm/sdk/market/pricefeeds/updates/fetchRedstonePayloads.js

@@ -0,0 +1,124 @@
+import { DataServiceWrapper } from "@redstone-finance/evm-connector";
+import {
+  RedstonePayload
+} from "@redstone-finance/protocol";
+import {
+  getSignersForDataServiceId
+} from "@redstone-finance/sdk";
+import { encodeAbiParameters, toBytes } from "viem";
+import { retry } from "../../../utils/index.js";
+async function fetchRedstonePayloads(options) {
+  const {
+    dataServiceId,
+    dataFeedsIds,
+    uniqueSignersCount,
+    historicalTimestampMs,
+    gateways,
+    ignoreMissingFeeds,
+    enableLogging,
+    logger
+  } = options;
+  const metadataTimestampMs = historicalTimestampMs ?? options.metadataTimestampMs;
+  const dataPackagesIds = Array.from(new Set(dataFeedsIds));
+  if (dataPackagesIds.length === 0) {
+    return [];
+  }
+  const wrapper = new DataServiceWrapper({
+    dataServiceId,
+    dataPackagesIds,
+    uniqueSignersCount,
+    authorizedSigners: getSignersForDataServiceId(
+      dataServiceId
+    ),
+    historicalTimestamp: historicalTimestampMs,
+    urls: gateways,
+    ignoreMissingFeed: ignoreMissingFeeds,
+    enableEnhancedLogs: enableLogging
+  });
+  if (metadataTimestampMs) {
+    wrapper.setMetadataTimestamp(metadataTimestampMs);
+  }
+  const dataPayload = await retry(() => wrapper.prepareRedstonePayload(true), {
+    attempts: 5,
+    interval: historicalTimestampMs ? 30500 : 250
+  });
+  const parsed = RedstonePayload.parse(toBytes(`0x${dataPayload}`));
+  const packagesByDataFeedId = groupDataPackages(parsed.signedDataPackages);
+  const result = [];
+  for (const dataFeedId of dataFeedsIds) {
+    const signedDataPackages = packagesByDataFeedId[dataFeedId];
+    if (!signedDataPackages) {
+      if (ignoreMissingFeeds) {
+        logger?.warn(`cannot find data packages for ${dataFeedId}`);
+        continue;
+      }
+      throw new Error(`cannot find data packages for ${dataFeedId}`);
+    }
+    if (signedDataPackages.length !== uniqueSignersCount) {
+      if (ignoreMissingFeeds) {
+        logger?.warn(
+          `got ${signedDataPackages.length} data packages for ${dataFeedId}, but expected ${uniqueSignersCount}`
+        );
+        continue;
+      }
+      throw new Error(
+        `got ${signedDataPackages.length} data packages for ${dataFeedId}, but expected ${uniqueSignersCount}`
+      );
+    }
+    result.push(
+      getCalldataWithTimestamp(
+        dataFeedId,
+        signedDataPackages,
+        wrapper.getUnsignedMetadata()
+      )
+    );
+  }
+  return result;
+}
+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);
+  }
+  return packagesByDataFeedId;
+}
+function getCalldataWithTimestamp(dataFeedId, packages, unsignedMetadata) {
+  const originalPayload = RedstonePayload.prepare(packages, unsignedMetadata);
+  const originalPayloadLength = originalPayload.length / 2;
+  const bytesToAdd = 32 - originalPayloadLength % 32;
+  const newUnsignedMetadata = unsignedMetadata + "_".repeat(bytesToAdd);
+  const payload = 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: encodeAbiParameters(
+      [{ type: "uint256" }, { type: "bytes" }],
+      [BigInt(timestamp), `0x${payload}`]
+    ),
+    timestamp,
+    cached: false
+  };
+}
+export {
+  fetchRedstonePayloads
+};

package/dist/esm/sdk/market/pricefeeds/updates/index.js

@@ -1,3 +1,5 @@
+export * from "./fetchPythPayloads.js";
+export * from "./fetchRedstonePayloads.js";
 import { PythOptions, PythUpdater } from "./PythUpdater.js";
 import { RedstoneOptions, RedstoneUpdater } from "./RedstoneUpdater.js";
 export {

package/dist/types/sdk/core/address-provider/AbstractAddressProviderContract.d.ts

@@ -3,10 +3,10 @@ import type { BaseContractArgs } from "../../base/BaseContract.js";
 import { BaseContract, type ConstructOptions } from "../../base/index.js";
 import type { VersionRange } from "../../constants/index.js";
 import type { AddressProviderV3StateHuman } from "../../types/index.js";
-import type { AddressProviderState } from "./types.js";
+import type { AddressProviderAddresses, AddressProviderState } from "./types.js";
 export default abstract class AbstractAddressProviderContract<abi extends Abi | readonly unknown[]> extends BaseContract<abi> {
     #private;
-    constructor(options: ConstructOptions, args: BaseContractArgs<abi>, addresses?: Record<string, Record<number, Address>>);
+    constructor(options: ConstructOptions, args: BaseContractArgs<abi>, addresses?: AddressProviderAddresses);
     protected setInternalAddress(key: string, address: Address, version: number): void;
     getAddress(contract: string, version?: number): Address;
     getLatest(contract: string, range: VersionRange): [address: Address, version: number] | undefined;

package/dist/types/sdk/core/address-provider/AddressProviderV300Contract.d.ts

@@ -1,7 +1,7 @@
 import type { Address, ContractEventName, DecodeFunctionDataReturnType, Log } from "viem";
 import type { ConstructOptions } from "../../base/Construct.js";
 import AbstractAddressProviderContract from "./AbstractAddressProviderContract.js";
-import type { IAddressProviderContract } from "./types.js";
+import type { AddressProviderAddresses, IAddressProviderContract } from "./types.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly name: "addresses";
@@ -89,7 +89,7 @@ declare const abi: readonly [{
 }];
 type abi = typeof abi;
 export declare class AddressProviderV300Contract extends AbstractAddressProviderContract<abi> implements IAddressProviderContract {
-    constructor(options: ConstructOptions, address: Address, version: number, addresses?: Record<string, Record<number, Address>>);
+    constructor(options: ConstructOptions, address: Address, version: number, addresses?: AddressProviderAddresses);
     protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
     syncState(blockNumber?: bigint): Promise<void>;

package/dist/types/sdk/core/address-provider/AddressProviderV310Contract.d.ts

@@ -1,7 +1,7 @@
 import type { Address, ContractEventName, DecodeFunctionDataReturnType, Log } from "viem";
 import type { ConstructOptions } from "../../base/Construct.js";
 import AbstractAddressProviderContract from "./AbstractAddressProviderContract.js";
-import type { IAddressProviderContract } from "./types.js";
+import type { AddressProviderAddresses, IAddressProviderContract } from "./types.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [];
@@ -254,7 +254,7 @@ declare const abi: readonly [{
 }];
 type abi = typeof abi;
 export declare class AddressProviderV310Contract extends AbstractAddressProviderContract<abi> implements IAddressProviderContract {
-    constructor(options: ConstructOptions, address: Address, version?: number, addresses?: Record<string, Record<number, Address>>);
+    constructor(options: ConstructOptions, address: Address, version?: number, addresses?: AddressProviderAddresses);
     protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
     syncState(blockNumber?: bigint): Promise<void>;

package/dist/types/sdk/core/address-provider/types.d.ts

@@ -2,6 +2,21 @@ import type { Address } from "viem";
 import type { BaseParams, IBaseContract } from "../../base/index.js";
 import type { VersionRange } from "../../constants/versions.js";
 import type { AddressProviderV3StateHuman } from "../../types/index.js";
+export interface AddressProviderAddresses {
+    /**
+     * Initialize address provider with these addresses
+     * Used in hydration
+     */
+    addresses?: Record<string, Record<number, Address>>;
+    /**
+     * Override addresses for this address provider
+     * These addresses will precede over addresses loaded from chain
+     *
+     * This is an escape hatch.
+     * We used it when we need to fix price feed compressor/market compressor urgently
+     */
+    overrides?: Record<string, Record<number, Address>>;
+}
 export interface AddressProviderState {
     baseParams: BaseParams;
     addresses: Record<string, Record<number, Address>>;

package/dist/types/sdk/market/pricefeeds/updates/fetchPythPayloads.d.ts

@@ -0,0 +1,30 @@
+import type { ILogger } from "../../../types/logger.js";
+import type { TimestampedCalldata } from "./types.js";
+export interface FetchPythPayloadsOptions {
+    /**
+     * Feeds to fetch
+     */
+    dataFeedsIds: Iterable<string>;
+    /**
+     * When true, will not throw an error if pyth is unable to fetch data for some feeds
+     */
+    ignoreMissingFeeds?: boolean;
+    /**
+     * Historical timestamp in seconds
+     */
+    historicalTimestampSeconds?: number;
+    /**
+     * Override Hermes API with this proxy. Can be used to set caching proxies, to avoid rate limiting
+     */
+    apiProxy?: string;
+    /**
+     * Logger to use
+     */
+    logger?: ILogger;
+}
+/**
+ * Fetches pyth payloads from Hermes API
+ * @param dataFeedsIds
+ * @returns
+ */
+export declare function fetchPythPayloads(options: FetchPythPayloadsOptions): Promise<TimestampedCalldata[]>;