@gearbox-protocol/sdk 15.0.0 → 15.1.0-next.1

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

@@ -1,19 +1,25 @@
-import type { Address, Hex, UnionOmit } from "viem";
-import type { IBaseContract, PriceFeedAnswer } from "../../base/index.js";
-import type { IPriceUpdateTx, PriceFeedStateHuman, RawTx } from "../../types/index.js";
-import type { PriceFeedRef } from "./PriceFeedRef.js";
+import { IBaseContract, PriceFeedAnswer } from "../../base/types.js";
+import { PriceFeedData } from "../../../model/opportunities.js";
+import "../../../model/index.js";
+import { PriceFeedStateHuman } from "../../types/state-human.js";
+import { PriceFeedRef } from "./PriceFeedRef.js";
+import { IPriceUpdateTx, RawTx } from "../../types/transactions.js";
+import "../../types/index.js";
+import "../../base/index.js";
+import { Address, Hex, UnionOmit } from "viem";
+//#region src/sdk/market/pricefeeds/types.d.ts
 /**
  * @internal
  * Indicates whether a price feed is used as the primary ("Main") or
  * fallback ("Reserve") oracle for a token. Gearbox uses dual-oracle
  * pricing to protect against oracle manipulation.
  **/
-export type PriceFeedUsageType = "Main" | "Reserve";
+type PriceFeedUsageType = "Main" | "Reserve";
 /**
  * Discriminator for the various on-chain price feed contract implementations
  * (e.g. Curve LP, Balancer, Pyth, Redstone).
  **/
-export type PriceFeedContractType = "PRICE_FEED::BALANCER_STABLE" | "PRICE_FEED::BALANCER_WEIGHTED" | "PRICE_FEED::BOUNDED" | "PRICE_FEED::COMPOSITE" | "PRICE_FEED::CONSTANT" | "PRICE_FEED::CURVE_CRYPTO" | "PRICE_FEED::CURVE_STABLE" | "PRICE_FEED::CURVE_USD" | "PRICE_FEED::ERC4626" | "PRICE_FEED::EXTERNAL" | "PRICE_FEED::MELLOW_LRT" | "PRICE_FEED::PENDLE_PT_TWAP" | "PRICE_FEED::PYTH" | "PRICE_FEED::REDSTONE" | "PRICE_FEED::WSTETH" | "PRICE_FEED::YEARN" | "PRICE_FEED::ZERO";
+type PriceFeedContractType = "PRICE_FEED::BALANCER_STABLE" | "PRICE_FEED::BALANCER_WEIGHTED" | "PRICE_FEED::BOUNDED" | "PRICE_FEED::COMPOSITE" | "PRICE_FEED::CONSTANT" | "PRICE_FEED::CURVE_CRYPTO" | "PRICE_FEED::CURVE_STABLE" | "PRICE_FEED::CURVE_USD" | "PRICE_FEED::ERC4626" | "PRICE_FEED::EXTERNAL" | "PRICE_FEED::MELLOW_LRT" | "PRICE_FEED::PENDLE_PT_TWAP" | "PRICE_FEED::PYTH" | "PRICE_FEED::REDSTONE" | "PRICE_FEED::WSTETH" | "PRICE_FEED::YEARN" | "PRICE_FEED::ZERO";
 /**
  * Public interface for a single price feed contract.
  *
@@ -21,94 +27,104 @@ export type PriceFeedContractType = "PRICE_FEED::BALANCER_STABLE" | "PRICE_FEED:
  * USD-denominated price with 8 decimals. Feeds are organized into trees:
  * composite feeds may depend on several underlying feeds.
  **/
-export interface IPriceFeedContract extends IBaseContract {
-    /**
-     * Whether this price feed enforces a lower-bound cap on its answer.
-     **/
-    readonly hasLowerBoundCap: boolean;
-    /**
-     * Discriminator identifying gearbox price feed type
-     **/
-    readonly priceFeedType: PriceFeedContractType;
-    /**
-     * Number of decimals in the price answer (typically 8).
-     **/
-    readonly decimals: number;
-    /**
-     * `true` if the on-chain contract implements `IUpdatablePriceFeed`,
-     * meaning its price can be refreshed via an off-chain data push.
-     **/
-    readonly updatable: boolean;
-    /**
-     * @internal
-     * `true` once the full feed configuration (decimals, skip-check flag,
-     * dependencies, etc.) has been loaded. A feed created from base params
-     * alone will have `loaded === false`.
-     **/
-    readonly loaded: boolean;
-    /**
-     * Latest price answer for this feed.
-     **/
-    readonly answer: PriceFeedAnswer;
-    /**
-     * Whether price feed implements its own safety and staleness checks
-     **/
-    readonly skipCheck: boolean;
-    /**
-     * Immediate child feeds that this composite feed depends on.
-     **/
-    readonly underlyingPriceFeeds: readonly PriceFeedRef[];
-    /**
-     * Replaces the cached answer with a new value.
-     * @param answer - New price answer to store.
-     **/
-    updateAnswer: (answer: PriceFeedAnswer) => void;
-    /**
-     * Returns a human-readable snapshot of this feed's state.
-     * @param raw - When `true`, includes raw/unformatted values.
-     **/
-    stateHuman: (raw?: boolean) => UnionOmit<PriceFeedStateHuman, "stalenessPeriod">;
-    /**
-     * Collects all updatable feeds in this feed's dependency tree,
-     * including this feed itself when it is updatable.
-     **/
-    updatableDependencies: () => IUpdatablePriceFeedContract[];
+interface IPriceFeedContract extends IBaseContract {
+  /**
+   * Whether this price feed enforces a lower-bound cap on its answer.
+   **/
+  readonly hasLowerBoundCap: boolean;
+  /**
+   * Discriminator identifying gearbox price feed type
+   **/
+  readonly priceFeedType: PriceFeedContractType;
+  /**
+   * Number of decimals in the price answer (typically 8).
+   **/
+  readonly decimals: number;
+  /**
+   * `true` if the on-chain contract implements `IUpdatablePriceFeed`,
+   * meaning its price can be refreshed via an off-chain data push.
+   **/
+  readonly updatable: boolean;
+  /**
+   * @internal
+   * `true` once the full feed configuration (decimals, skip-check flag,
+   * dependencies, etc.) has been loaded. A feed created from base params
+   * alone will have `loaded === false`.
+   **/
+  readonly loaded: boolean;
+  /**
+   * Latest price answer for this feed.
+   **/
+  readonly answer: PriceFeedAnswer;
+  /**
+   * Whether price feed implements its own safety and staleness checks
+   **/
+  readonly skipCheck: boolean;
+  /**
+   * Immediate child feeds that this composite feed depends on.
+   **/
+  readonly underlyingPriceFeeds: readonly PriceFeedRef[];
+  /**
+   * Replaces the cached answer with a new value.
+   * @param answer - New price answer to store.
+   **/
+  updateAnswer: (answer: PriceFeedAnswer) => void;
+  /**
+   * Returns a human-readable snapshot of this feed's state.
+   * @param raw - When `true`, includes raw/unformatted values.
+   **/
+  stateHuman: (raw?: boolean) => UnionOmit<PriceFeedStateHuman, "stalenessPeriod">;
+  /**
+   * Collects all updatable feeds in this feed's dependency tree,
+   * including this feed itself when it is updatable.
+   **/
+  updatableDependencies: () => IUpdatablePriceFeedContract[];
+  /**
+   * Describes this feed and the feeds it reads from the way the shared read
+   * model does.
+   *
+   * A feed whose dependencies were never loaded is described as a leaf rather
+   * than throwing: the tree decorates a detail screen, nobody computes with it.
+   **/
+  describe: () => PriceFeedData;
 }
 /**
  * Extended price feed interface for feeds whose price can be refreshed
  * via an off-chain data push (e.g. Pyth or Redstone feeds).
  **/
-export interface IUpdatablePriceFeedContract extends IPriceFeedContract {
-    /**
-     * Builds a raw transaction that pushes new price data to the on-chain feed.
-     * @param data - ABI-encoded update payload.
-     **/
-    createPriceUpdateTx: (data: `0x${string}`) => RawTx;
+interface IUpdatablePriceFeedContract extends IPriceFeedContract {
+  /**
+   * Builds a raw transaction that pushes new price data to the on-chain feed.
+   * @param data - ABI-encoded update payload.
+   **/
+  createPriceUpdateTx: (data: `0x${string}`) => RawTx;
 }
 /**
  * Result of generating price-feed update transactions.
  **/
-export interface UpdatePriceFeedsResult {
-    /**
-     * Transactions that push fresh prices to updatable feeds.
-     **/
-    txs: IPriceUpdateTx[];
-    /**
-     * Latest timestamp among all fetched price updates (unix seconds).
-     **/
-    timestamp: number;
+interface UpdatePriceFeedsResult {
+  /**
+   * Transactions that push fresh prices to updatable feeds.
+   **/
+  txs: IPriceUpdateTx[];
+  /**
+   * Latest timestamp among all fetched price updates (unix seconds).
+   **/
+  timestamp: number;
 }
 /**
  * Pair: updatable price feed address and
  * data can be passed to IUpdatablePriceFeed.updatePrice
  */
-export interface PriceUpdate {
-    /**
-     * IUpdatablePriceFeed contract address
-     */
-    priceFeed: Address;
-    /**
-     * Data that can be passed to IUpdatablePriceFeed.updatePrice
-     */
-    data: Hex;
+interface PriceUpdate {
+  /**
+   * IUpdatablePriceFeed contract address
+   */
+  priceFeed: Address;
+  /**
+   * Data that can be passed to IUpdatablePriceFeed.updatePrice
+   */
+  data: Hex;
 }
+//#endregion
+export { IPriceFeedContract, IUpdatablePriceFeedContract, PriceFeedContractType, PriceFeedUsageType, PriceUpdate, UpdatePriceFeedsResult };

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

@@ -1,13 +1,17 @@
-import type { IPriceUpdateTx, RawTx } from "../../../types/index.js";
-import type { IPriceUpdateTask } from "./types.js";
-export declare abstract class PriceUpdateTx<T extends IPriceUpdateTask = IPriceUpdateTask> implements IPriceUpdateTx<T> {
-    /**
-     * raw tx with encoded `priceFeed.updatePrice` call
-     */
-    readonly raw: RawTx;
-    readonly data: T;
-    abstract readonly name: string;
-    constructor(raw: RawTx, data: T);
-    get pretty(): string;
-    validateTimestamp(blockTimestamp: bigint): "valid" | "too old" | "in future";
+import { IPriceUpdateTask } from "./types.js";
+import { IPriceUpdateTx, RawTx } from "../../../types/transactions.js";
+import "../../../types/index.js";
+//#region src/sdk/market/pricefeeds/updates/PriceUpdateTx.d.ts
+declare abstract class PriceUpdateTx<T extends IPriceUpdateTask = IPriceUpdateTask> implements IPriceUpdateTx<T> {
+  /**
+   * raw tx with encoded `priceFeed.updatePrice` call
+   */
+  readonly raw: RawTx;
+  readonly data: T;
+  abstract readonly name: string;
+  constructor(raw: RawTx, data: T);
+  get pretty(): string;
+  validateTimestamp(blockTimestamp: bigint): "valid" | "too old" | "in future";
 }
+//#endregion
+export { PriceUpdateTx };

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

@@ -1,17 +1,20 @@
-import type { TimestampedCalldata } from "./types.js";
-export interface PriceUpdatesCacheOptions {
-    /**
-     * Assume that in historical mode we only need to fetch once and then reuse from cache forever
-     */
-    historical: boolean;
-    /**
-     * TTL in milliseconds
-     */
-    ttl: number;
+import { TimestampedCalldata } from "./types.js";
+//#region src/sdk/market/pricefeeds/updates/PriceUpdatesCache.d.ts
+interface PriceUpdatesCacheOptions {
+  /**
+   * Assume that in historical mode we only need to fetch once and then reuse from cache forever
+   */
+  historical: boolean;
+  /**
+   * TTL in milliseconds
+   */
+  ttl: number;
 }
-export declare class PriceUpdatesCache {
-    #private;
-    constructor(opts: PriceUpdatesCacheOptions);
-    get(...path: Array<number | string>): Omit<TimestampedCalldata, "cached"> | undefined;
-    set(value: Omit<TimestampedCalldata, "cached">, ...path: Array<number | string>): void;
+declare class PriceUpdatesCache {
+  #private;
+  constructor(opts: PriceUpdatesCacheOptions);
+  get(...path: Array<number | string>): Omit<TimestampedCalldata, "cached"> | undefined;
+  set(value: Omit<TimestampedCalldata, "cached">, ...path: Array<number | string>): void;
 }
+//#endregion
+export { PriceUpdatesCache, PriceUpdatesCacheOptions };

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

@@ -1,34 +1,37 @@
-import { z } from "zod/v4";
-import { SDKConstruct } from "../../../base/index.js";
-import type { OnchainSDK } from "../../../OnchainSDK.js";
-import type { IPriceFeedContract } from "../types.js";
+import { IPriceFeedContract } from "../types.js";
+import { IPriceUpdateTask, IPriceUpdater } from "./types.js";
 import { PriceUpdatesCache } from "./PriceUpdatesCache.js";
 import { PriceUpdateTx } from "./PriceUpdateTx.js";
-import type { IPriceUpdater, IPriceUpdateTask } from "./types.js";
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { SDKConstruct } from "../../../base/SDKConstruct.js";
+import "../../../base/index.js";
+import { z } from "zod/v4";
+//#region src/sdk/market/pricefeeds/updates/RedstoneUpdater.d.ts
 interface RedstoneUpdateTask extends IPriceUpdateTask {
-    dataServiceId: string;
+  dataServiceId: string;
 }
 declare class RedstoneUpdateTx extends PriceUpdateTx<RedstoneUpdateTask> {
-    readonly name = "redstone";
+  readonly name = "redstone";
 }
-export declare const RedstoneOptions: z.ZodObject<{
-    historicTimestamp: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<true>]>>;
-    gateways: z.ZodOptional<z.ZodArray<z.ZodURL>>;
-    cacheTTL: z.ZodOptional<z.ZodNumber>;
-    failOnMissingFeeds: z.ZodOptional<z.ZodBoolean>;
-    enableLogging: z.ZodOptional<z.ZodBoolean>;
+declare const RedstoneOptions: z.ZodObject<{
+  historicTimestamp: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<true>]>>;
+  gateways: z.ZodOptional<z.ZodArray<z.ZodURL>>;
+  cacheTTL: z.ZodOptional<z.ZodNumber>;
+  failOnMissingFeeds: z.ZodOptional<z.ZodBoolean>;
+  enableLogging: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
-export type RedstoneOptions = z.infer<typeof RedstoneOptions> & {
-    /** Shared cache injected by {@link MultichainSDK} to avoid redundant fetches. */
-    cache?: PriceUpdatesCache;
+type RedstoneOptions = z.infer<typeof RedstoneOptions> & {
+  /** Shared cache injected by {@link MultichainSDK} to avoid redundant fetches. */
+  cache?: PriceUpdatesCache;
 };
 /**
  * Class to update multiple redstone price feeds at once
  */
-export declare class RedstoneUpdater extends SDKConstruct implements IPriceUpdater<RedstoneUpdateTask> {
-    #private;
-    constructor(sdk: OnchainSDK, opts?: RedstoneOptions);
-    getUpdateTxs(feeds: IPriceFeedContract[]): Promise<RedstoneUpdateTx[]>;
-    get historical(): boolean;
+declare class RedstoneUpdater extends SDKConstruct implements IPriceUpdater<RedstoneUpdateTask> {
+  #private;
+  constructor(sdk: OnchainSDK, opts?: RedstoneOptions);
+  getUpdateTxs(feeds: IPriceFeedContract[]): Promise<RedstoneUpdateTx[]>;
+  get historical(): boolean;
 }
-export {};
+//#endregion
+export { RedstoneOptions, RedstoneUpdater };

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

@@ -1,59 +1,62 @@
-import type { ILogger } from "../../../types/logger.js";
-import type { TimestampedCalldata, TimestampedCalldataWithPrice } from "./types.js";
-export interface FetchRedstonePayloadsOptions {
-    /**
-     * Redstone data service id
-     * Most likely "redstone-primary-prod"
-     */
-    dataServiceId: string;
-    /**
-     * Feeds to fetch
-     */
-    dataFeedsIds: Iterable<string>;
-    /**
-     * Ensure minimum number of signers for each feed
-     */
-    uniqueSignersCount: number;
-    /**
-     * Historical timestamp in milliseconds
-     * Must be rounded to the nearest minute
-     */
-    historicalTimestampMs?: number;
-    /**
-     * Metadata timestamp in milliseconds, if undefined, will be set to historical timestamp
-     * Can be used to set deterministic metadata timestamp, so requests sent by two services at the same block are identical
-     */
-    metadataTimestampMs?: number;
-    /**
-     * Redstone gateways (put caching proxies here to avoid rate limiting)
-     */
-    gateways?: string[];
-    /**
-     * Enable redstone internal logging
-     */
-    enableLogging?: boolean;
-    /**
-     * When true, will throw an error if redstone is unable to fetch data for some feeds
-     */
-    failOnMissingFeeds?: boolean;
-    /**
-     * Logger to use
-     */
-    logger?: ILogger;
-    /**
-     * When true, returns the price data for each feed.
-     */
-    returnPrices?: boolean;
+import { ILogger } from "../../../types/logger.js";
+import { TimestampedCalldata, TimestampedCalldataWithPrice } from "./types.js";
+//#region src/sdk/market/pricefeeds/updates/fetchRedstonePayloads.d.ts
+interface FetchRedstonePayloadsOptions {
+  /**
+   * Redstone data service id
+   * Most likely "redstone-primary-prod"
+   */
+  dataServiceId: string;
+  /**
+   * Feeds to fetch
+   */
+  dataFeedsIds: Iterable<string>;
+  /**
+   * Ensure minimum number of signers for each feed
+   */
+  uniqueSignersCount: number;
+  /**
+   * Historical timestamp in milliseconds
+   * Must be rounded to the nearest minute
+   */
+  historicalTimestampMs?: number;
+  /**
+   * Metadata timestamp in milliseconds, if undefined, will be set to historical timestamp
+   * Can be used to set deterministic metadata timestamp, so requests sent by two services at the same block are identical
+   */
+  metadataTimestampMs?: number;
+  /**
+   * Redstone gateways (put caching proxies here to avoid rate limiting)
+   */
+  gateways?: string[];
+  /**
+   * Enable redstone internal logging
+   */
+  enableLogging?: boolean;
+  /**
+   * When true, will throw an error if redstone is unable to fetch data for some feeds
+   */
+  failOnMissingFeeds?: boolean;
+  /**
+   * Logger to use
+   */
+  logger?: ILogger;
+  /**
+   * When true, returns the price data for each feed.
+   */
+  returnPrices?: boolean;
 }
 /**
  * Fetches redstone payloads with price data
  */
-export declare function fetchRedstonePayloads(options: FetchRedstonePayloadsOptions & {
-    returnPrices: true;
+declare function fetchRedstonePayloads(options: FetchRedstonePayloadsOptions & {
+  returnPrices: true;
 }): Promise<TimestampedCalldataWithPrice[]>;
 /**
  * Fetches redstone payloads
  */
-export declare function fetchRedstonePayloads(options: FetchRedstonePayloadsOptions & {
-    returnPrices?: false;
+declare function fetchRedstonePayloads(options: FetchRedstonePayloadsOptions & {
+  returnPrices?: false;
 }): Promise<TimestampedCalldata[]>;
+//#endregion
+export { FetchRedstonePayloadsOptions, fetchRedstonePayloads };

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

@@ -1,4 +1,5 @@
-export * from "./fetchRedstonePayloads.js";
-export { PriceUpdatesCache } from "./PriceUpdatesCache.js";
-export { RedstoneOptions, RedstoneUpdater } from "./RedstoneUpdater.js";
-export type * from "./types.js";
+import { IPriceUpdateTask, IPriceUpdater, TimestampedCalldata, TimestampedCalldataWithPrice } from "./types.js";
+import { FetchRedstonePayloadsOptions, fetchRedstonePayloads } from "./fetchRedstonePayloads.js";
+import { PriceUpdatesCache } from "./PriceUpdatesCache.js";
+import { RedstoneOptions, RedstoneUpdater } from "./RedstoneUpdater.js";
+export { FetchRedstonePayloadsOptions, type IPriceUpdateTask, type IPriceUpdater, PriceUpdatesCache, RedstoneOptions, RedstoneUpdater, type TimestampedCalldata, type TimestampedCalldataWithPrice, fetchRedstonePayloads };

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

@@ -1,29 +1,33 @@
-import type { Address } from "viem";
-import type { IPriceUpdateTx } from "../../../types/index.js";
-import type { IPriceFeedContract } from "../types.js";
-export interface IPriceUpdateTask {
-    dataFeedId: string;
-    priceFeed: Address;
-    timestamp: number;
-    cached: boolean;
+import { IPriceFeedContract } from "../types.js";
+import { IPriceUpdateTx } from "../../../types/transactions.js";
+import "../../../types/index.js";
+import { Address } from "viem";
+//#region src/sdk/market/pricefeeds/updates/types.d.ts
+interface IPriceUpdateTask {
+  dataFeedId: string;
+  priceFeed: Address;
+  timestamp: number;
+  cached: boolean;
 }
-export interface IPriceUpdater<T extends IPriceUpdateTask = IPriceUpdateTask> {
-    getUpdateTxs: (feeds: IPriceFeedContract[]) => Promise<IPriceUpdateTx<T>[]>;
-    /**
-     * Returns true if the updater is in historical mode
-     */
-    historical: boolean;
+interface IPriceUpdater<T extends IPriceUpdateTask = IPriceUpdateTask> {
+  getUpdateTxs: (feeds: IPriceFeedContract[]) => Promise<IPriceUpdateTx<T>[]>;
+  /**
+   * Returns true if the updater is in historical mode
+   */
+  historical: boolean;
 }
-export interface TimestampedCalldata {
-    dataFeedId: string;
-    data: `0x${string}`;
-    /**
-     * This timestamp is in seconds
-     */
-    timestamp: number;
-    cached: boolean;
+interface TimestampedCalldata {
+  dataFeedId: string;
+  data: `0x${string}`;
+  /**
+   * This timestamp is in seconds
+   */
+  timestamp: number;
+  cached: boolean;
 }
-export interface TimestampedCalldataWithPrice extends TimestampedCalldata {
-    price: bigint;
-    decimals: number;
+interface TimestampedCalldataWithPrice extends TimestampedCalldata {
+  price: bigint;
+  decimals: number;
 }
+//#endregion
+export { IPriceUpdateTask, IPriceUpdater, TimestampedCalldata, TimestampedCalldataWithPrice };

package/dist/types/sdk/market/rwa/RWARegistry.d.ts

@@ -1,8 +1,12 @@
-import type { Address } from "abitype";
-import { SDKConstruct } from "../../base/index.js";
-import type { DelegatedMulticall } from "../../utils/viem/index.js";
-import { SecuritizeRWAFactory } from "./securitize/index.js";
-import type { RWACompressorResponse, RWAInvestorData, RWAState, RWAStateHuman } from "./types.js";
+import { DelegatedMulticall } from "../../utils/viem/executeDelegatedMulticalls.js";
+import "../../utils/viem/index.js";
+import { RWACompressorResponse, RWAInvestorData, RWAState, RWAStateHuman } from "./types.js";
+import { SecuritizeRWAFactory } from "./securitize/SecuritizeRWAFactory.js";
+import "./securitize/index.js";
+import { SDKConstruct } from "../../base/SDKConstruct.js";
+import "../../base/index.js";
+import { Address } from "abitype";
+//#region src/sdk/market/rwa/RWARegistry.d.ts
 /**
  * Registry of RWA underlying tokens and RWA factory contracts.
  *
@@ -10,43 +14,46 @@ import type { RWACompressorResponse, RWAInvestorData, RWAState, RWAStateHuman }
  * during SDK attach/hydrate. Provides methods to query investor-level data and
  * to resolve RWA factory instances by address.
  **/
-export declare class RWARegistry extends SDKConstruct {
-    #private;
-    /**
-     * @internal
-     *
-     * Returns delegated multicalls for loading all RWA underlying tokens from the on-chain RWA compressor.
-     * Used by the SDK to compose batched RPC calls.
-     *
-     * @param configurators - Market configurators to query.
-     * @param rwaFactories - RWA factory contracts to query.
-     */
-    getLoadMulticalls(configurators: Address[], rwaFactories?: Address[]): DelegatedMulticall[];
-    /**
-     * Fetches decoded investor data from the on-chain RWA compressor.
-     *
-     * Each factory produces its own investor data (e.g. registered tokens,
-     * cached signatures, EIP-712 messages to sign).
-     *
-     * @param investor - Investor EOA address.
-     * @param factories_ - Optional subset of factory addresses to query.
-     *   When omitted, all loaded factories are used.
-     */
-    getInvestorData(investor: Address, factories_?: Address[]): Promise<RWAInvestorData[]>;
-    /** All loaded RWA factory instances. */
-    get factories(): SecuritizeRWAFactory[];
-    /** Raw RWA compressor response, or `undefined` before attach/hydrate. */
-    get state(): RWAState | undefined;
-    /**
-     * Returns a human-readable snapshot of the RWA state.
-     */
-    stateHuman(raw?: boolean): RWAStateHuman;
-    /**
-     * @internal
-     *
-     * Replaces the internal state with a new RWA compressor response.
-     * Rebuilds token metadata for RWA underlyings and re-instantiates factory
-     * wrappers.
-     */
-    setState(resp?: RWACompressorResponse): void;
+declare class RWARegistry extends SDKConstruct {
+  #private;
+  /**
+   * @internal
+   *
+   * Returns delegated multicalls for loading all RWA underlying tokens from the on-chain RWA compressor.
+   * Used by the SDK to compose batched RPC calls.
+   *
+   * @param configurators - Market configurators to query.
+   * @param rwaFactories - RWA factory contracts to query.
+   */
+  getLoadMulticalls(configurators: Address[], rwaFactories?: Address[]): DelegatedMulticall[];
+  /**
+   * Fetches decoded investor data from the on-chain RWA compressor.
+   *
+   * Each factory produces its own investor data (e.g. registered tokens,
+   * cached signatures, EIP-712 messages to sign).
+   *
+   * @param investor - Investor EOA address.
+   * @param factories_ - Optional subset of factory addresses to query.
+   *   When omitted, all loaded factories are used.
+   * @param blockNumber - Block to read at, defaults to the latest block.
+   */
+  getInvestorData(investor: Address, factories_?: Address[], blockNumber?: bigint): Promise<RWAInvestorData[]>;
+  /** All loaded RWA factory instances. */
+  get factories(): SecuritizeRWAFactory[];
+  /** Raw RWA compressor response, or `undefined` before attach/hydrate. */
+  get state(): RWAState | undefined;
+  /**
+   * Returns a human-readable snapshot of the RWA state.
+   */
+  stateHuman(raw?: boolean): RWAStateHuman;
+  /**
+   * @internal
+   *
+   * Replaces the internal state with a new RWA compressor response.
+   * Rebuilds token metadata for RWA underlyings and re-instantiates factory
+   * wrappers.
+   */
+  setState(resp?: RWACompressorResponse): void;
 }
+//#endregion
+export { RWARegistry };