@gearbox-protocol/sdk 17.10.1 → 17.11.0

package/dist/types/permissionless/api/chains/ChainsNamespace.d.ts

@@ -0,0 +1,99 @@
+import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
+import { GearboxPermissionlessOptions } from "../types.js";
+import { AttachChainsArgs, ChainSummaryArgs, PermissionlessChain, PermissionlessChainSummary } from "./types.js";
+import { Chain, PublicClient, Transport } from "viem";
+//#region src/permissionless/api/chains/ChainsNamespace.d.ts
+/**
+ * The chains the permissionless stack runs on, and the viem clients that
+ * reach them.
+ *
+ * Both halves live here because they answer the same question. Which chains
+ * exist is the backend's to decide — it holds rows for chains it does not
+ * serve, and those must not be reachable — so the list is also the only
+ * honest basis for deciding which clients to build. Nothing is passed in: a
+ * caller that had to name the chains could name one the backend does not
+ * serve, or miss one it does.
+ *
+ * The list is fetched once, by {@link attach}, and kept for the client's
+ * lifetime:
+ *
+ * ```ts
+ * await permissionless.attach();
+ * const chains = permissionless.chains.list();
+ * ```
+ *
+ * Every read before that throws {@link PermissionlessNotAttachedError} rather
+ * than answering with an empty list, which would be indistinguishable from a
+ * backend that serves nothing.
+ *
+ * What {@link attach} reads is only what identifies a chain. The counters a
+ * list renders next to one are {@link summary}, a second read, because they
+ * aggregate over every market the backend knows and nothing should wait on
+ * that to start.
+ **/
+declare class ChainsNamespace extends AbstractOffchainNamespace {
+  #private;
+  constructor(options: GearboxPermissionlessOptions);
+  /**
+   * Reads the chain list off the backend and builds a client for each chain
+   * it names.
+   *
+   * Idempotent, and joins a call already in flight, so a double invocation —
+   * React's StrictMode, two components mounting at once — costs one request.
+   * A second call with a different `scope` is a no-op: the list is decided
+   * once.
+   **/
+  attach({ scope }?: AttachChainsArgs): Promise<void>;
+  /**
+   * Whether {@link attach} has completed.
+   **/
+  get isAttached(): boolean;
+  /**
+   * Every chain the backend serves, in the order it listed them.
+   **/
+  list(): PermissionlessChain[];
+  /**
+   * One chain by id, or nothing when the backend does not serve it.
+   *
+   * Reads the attached list rather than a route of its own, which is also
+   * what makes "not served" and "not activated" distinguishable: the first is
+   * absence here, the second is {@link PermissionlessChain.isActivated}.
+   **/
+  find(chainId: number): PermissionlessChain | undefined;
+  /**
+   * The same chains, with the counters a list renders next to them.
+   *
+   * A read of its own, and not part of {@link attach}: the counters aggregate
+   * over every market configurator and market the backend knows, which is
+   * slow enough that waiting on it would hold up the whole client. A list
+   * renders off {@link list} and fills the numbers in when this resolves.
+   *
+   * Nothing is cached — each call is a request — so a caller that renders
+   * this should hold it in whatever already owns its async state.
+   *
+   * Covers the scope {@link attach} settled on unless one is named here, so
+   * the counters describe the list that is already on screen rather than a
+   * different set of chains.
+   *
+   * ```ts
+   * await permissionless.attach();
+   * const chains = permissionless.chains.list();
+   * const withCounters = await permissionless.chains.summary();
+   * ```
+   **/
+  summary({ scope }?: ChainSummaryArgs): Promise<PermissionlessChainSummary[]>;
+  /**
+   * Chains a client could be built for. A subset of {@link list} — see
+   * {@link client}.
+   **/
+  get chainIds(): number[];
+  /**
+   * The client for one chain.
+   *
+   * @throws {@link PermissionlessChainUnreachableError} when the backend does
+   * not serve the chain, or serves one this SDK carries no definition for.
+   **/
+  client(chainId: number): PublicClient<Transport, Chain>;
+}
+//#endregion
+export { ChainsNamespace };

package/dist/types/permissionless/api/chains/index.d.ts

@@ -0,0 +1,3 @@
+import { AttachChainsArgs, ChainScope, ChainSummaryArgs, PermissionlessChain, PermissionlessChainSummary } from "./types.js";
+import { ChainsNamespace } from "./ChainsNamespace.js";
+export { AttachChainsArgs, ChainScope, ChainSummaryArgs, ChainsNamespace, PermissionlessChain, PermissionlessChainSummary };

package/dist/types/permissionless/api/chains/schemas.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod/v4";
+//#region src/permissionless/api/chains/schemas.d.ts
+/**
+ * Runtime schema for {@link PermissionlessChain}.
+ **/
+declare const chainSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  name: z.ZodString;
+  isPublic: z.ZodBoolean;
+  isActivated: z.ZodBoolean;
+  explorerUrl: z.ZodString;
+}, z.core.$loose>;
+/** What `GET /chain/list` answers with. */
+declare const chainListSchema: z.ZodArray<z.ZodObject<{
+  chainId: z.ZodNumber;
+  name: z.ZodString;
+  isPublic: z.ZodBoolean;
+  isActivated: z.ZodBoolean;
+  explorerUrl: z.ZodString;
+}, z.core.$loose>>;
+/**
+ * Runtime schema for {@link PermissionlessChainSummary}.
+ *
+ * Strict about the two counters on purpose: they are the only reason this
+ * read exists, and a backend that answered without them would render as
+ * dashes where the numbers belong — a skew worth failing on rather than
+ * displaying.
+ **/
+declare const chainSummarySchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  name: z.ZodString;
+  isPublic: z.ZodBoolean;
+  isActivated: z.ZodBoolean;
+  explorerUrl: z.ZodString;
+  riskCuratorsQty: z.ZodNumber;
+  marketsQty: z.ZodNumber;
+}, z.core.$loose>;
+/** What `GET /chain/summary` answers with. */
+declare const chainSummaryListSchema: z.ZodArray<z.ZodObject<{
+  chainId: z.ZodNumber;
+  name: z.ZodString;
+  isPublic: z.ZodBoolean;
+  isActivated: z.ZodBoolean;
+  explorerUrl: z.ZodString;
+  riskCuratorsQty: z.ZodNumber;
+  marketsQty: z.ZodNumber;
+}, z.core.$loose>>;
+//#endregion
+export { chainListSchema, chainSchema, chainSummaryListSchema, chainSummarySchema };

package/dist/types/permissionless/api/chains/types.d.ts

@@ -0,0 +1,58 @@
+//#region src/permissionless/api/chains/types.d.ts
+/**
+ * Which chains a read covers:
+ *
+ * - `public` — the ones open to everyone, the backend's default;
+ * - `all` — those plus the private ones the caller may see.
+ **/
+type ChainScope = "public" | "all";
+/**
+ * One chain the permissionless stack is deployed on.
+ *
+ * This list is what exists: the backend holds rows for chains it does not
+ * serve, and those are not reachable through it.
+ *
+ * Deliberately bare. It is read during {@link ChainsNamespace.attach}, which
+ * every other call waits on, so it carries only what identifies a chain and
+ * decides whether to show it. The counters are a second read, see
+ * {@link PermissionlessChainSummary}.
+ **/
+interface PermissionlessChain {
+  chainId: number;
+  name: string;
+  /** Whether the instance is open to everyone, or only to its own curators. */
+  isPublic: boolean;
+  /**
+   * Whether the instance is live. A pending one has nothing to show, and the
+   * default `public` scope leaves it out.
+   **/
+  isActivated: boolean;
+  explorerUrl: string;
+}
+/**
+ * A chain with the counters a list renders next to it, see
+ * {@link ChainsNamespace.summary}.
+ **/
+interface PermissionlessChainSummary extends PermissionlessChain {
+  riskCuratorsQty: number;
+  marketsQty: number;
+}
+/** Args of {@link ChainsNamespace.attach}. */
+interface AttachChainsArgs {
+  /**
+   * @defaultValue `"public"`
+   **/
+  scope?: ChainScope;
+}
+/** Args of {@link ChainsNamespace.summary}. */
+interface ChainSummaryArgs {
+  /**
+   * Which chains to count.
+   *
+   * @defaultValue the scope {@link ChainsNamespace.attach} settled on, so
+   * the counters describe the list already on screen.
+   **/
+  scope?: ChainScope;
+}
+//#endregion
+export { AttachChainsArgs, ChainScope, ChainSummaryArgs, PermissionlessChain, PermissionlessChainSummary };

package/dist/types/permissionless/api/deploy/PermissionlessDeploy.d.ts

@@ -0,0 +1,69 @@
+import { ChainsNamespace } from "../chains/ChainsNamespace.js";
+import { DeployContractArgs, DeployPriceFeedArgs, PreparedDeployment, PreparedPriceFeedDeployment } from "./types.js";
+import { Hex } from "viem";
+//#region src/permissionless/api/deploy/PermissionlessDeploy.d.ts
+/**
+ * Salt a generic contract deploy gets when the caller does not name one. Two
+ * deploys of the same type and arguments by the same owner collide under it,
+ * which for a singleton like a pause committee is the point.
+ **/
+declare const DEFAULT_DEPLOY_SALT: Hex;
+/**
+ * The salt a price feed is deployed under, derived from its name so that two
+ * feeds of the same type and arguments get different addresses.
+ **/
+declare function priceFeedSalt(name: string): Hex;
+/**
+ * Deploys through the BytecodeRepository: the constructor arguments it wants,
+ * the CREATE2 address those produce, and the transaction that gets there.
+ *
+ * Entirely on-chain — no backend is involved, every answer is derived from the
+ * target chain. Nothing is sent either: a browser holds the only wallet, so a
+ * call prepares the deploy and the caller sends
+ * {@link PreparedDeployment.tx} with whatever signs for them.
+ *
+ * ```ts
+ * const feed = await permissionless.deploy.priceFeed({
+ *   chainId: 1,
+ *   owner: account,
+ *   contractType: "PRICE_FEED::CHAINLINK",
+ *   version: 310,
+ *   name: "WETH / USD",
+ *   values,
+ * });
+ * if (!feed.isAlreadyDeployed) {
+ *   await sendRawTx(wallet, { tx: feed.tx });
+ * }
+ * ```
+ **/
+declare class PermissionlessDeploy {
+  #private;
+  constructor(chains: ChainsNamespace);
+  /**
+   * Prepares a price feed deploy from the values a form collected: encodes
+   * them the way the PriceFeedStore reads them back, and reports where the
+   * feed will land.
+   *
+   * A COMPOSITE's first leg is the one case where the values are not taken as
+   * given. It arrives with `stalenessPeriod` 0 whenever it is a derived feed,
+   * because the store registers those with 0 and rejects anything else — which
+   * says nothing about what the leg itself enforces. A composite built on that
+   * 0 can never pass its own staleness check, so the real bound is read off
+   * the leg, see {@link deriveEffectiveStalenessPeriod}.
+   *
+   * The deployed feed reaches {@link PermissionlessOracles.store} only once
+   * it is in the PriceFeedStore, which is a batch the instance owner
+   * executes, see {@link InstanceOwnerTransactions.addFeeds}.
+   **/
+  priceFeed(args: DeployPriceFeedArgs): Promise<PreparedPriceFeedDeployment>;
+  /**
+   * Prepares a generic contract deploy from ABI type/value pairs.
+   *
+   * Unlike a price feed, the arguments here are already typed by the caller,
+   * so nothing is looked up: they are encoded as given and the address they
+   * produce is reported.
+   **/
+  contract(args: DeployContractArgs): Promise<PreparedDeployment>;
+}
+//#endregion
+export { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt };

package/dist/types/permissionless/api/deploy/effective-staleness.d.ts

@@ -0,0 +1,19 @@
+import { Address, PublicClient } from "viem";
+//#region src/permissionless/api/deploy/effective-staleness.d.ts
+/**
+ * The staleness a deployed price feed enforces on the price it reports.
+ *
+ * This is deliberately not the value the feed is registered with in the
+ * PriceFeedStore — derived feeds must be registered with 0 there, and the store
+ * rejects anything else for them with `IncorrectParameterException()`. It is
+ * the value a parent feed needs when it re-checks the leg's `updatedAt`
+ * itself.
+ *
+ * Returns `null` when it cannot be determined. Callers must surface that
+ * rather than substitute a bound: a leg constructed with a staleness its
+ * underlying oracle can never satisfy produces a feed that reverts on every
+ * read and can never be added to the store.
+ **/
+declare function deriveEffectiveStalenessPeriod(client: PublicClient, address: Address): Promise<number | null>;
+//#endregion
+export { deriveEffectiveStalenessPeriod };

package/dist/types/permissionless/api/deploy/index.d.ts

@@ -0,0 +1,4 @@
+import { DeployArgs, DeployContractArgs, DeployPriceFeedArgs, PreparedDeployment, PreparedPriceFeedDeployment } from "./types.js";
+import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./PermissionlessDeploy.js";
+import { deriveEffectiveStalenessPeriod } from "./effective-staleness.js";
+export { DEFAULT_DEPLOY_SALT, DeployArgs, DeployContractArgs, DeployPriceFeedArgs, PermissionlessDeploy, PreparedDeployment, PreparedPriceFeedDeployment, deriveEffectiveStalenessPeriod, priceFeedSalt };

package/dist/types/permissionless/api/deploy/types.d.ts

@@ -0,0 +1,87 @@
+import { RawTx } from "../../../onchain/types/transactions.js";
+import "../../../onchain/index.js";
+import { InputValueParams } from "../../core/pricefeed-builder.js";
+import "../../core/index.js";
+import { FunctionParams } from "../../utils/abi-encoder.js";
+import { Address, Hex } from "viem";
+//#region src/permissionless/api/deploy/types.d.ts
+/**
+ * What both deploy flows name: which chain to read, and who the deployer is.
+ * `owner` goes into the CREATE2 derivation, so it has to be the address that
+ * will send {@link PreparedDeployment.tx} — anyone else's send lands on a
+ * different address.
+ *
+ * The chain must be among the ones the client was constructed with, see
+ * {@link GearboxPermissionlessOptions.chains}.
+ **/
+interface DeployArgs {
+  chainId: number;
+  owner: Address;
+  contractType: string;
+  version: number;
+}
+/** Args of {@link PermissionlessDeploy.priceFeed}. */
+interface DeployPriceFeedArgs extends DeployArgs {
+  /**
+   * Constructor values keyed by the labels of the feed's
+   * {@link PriceFeedSetupParams}, i.e. what a form collects.
+   **/
+  values: Record<string, InputValueParams>;
+  /**
+   * Name the feed is deployed under. Used as the CREATE2 salt unless
+   * {@link salt} is given, which is what makes two feeds of the same type and
+   * args land on different addresses.
+   **/
+  name?: string;
+  /** @see {@link priceFeedSalt} for the default derived from {@link name}. */
+  salt?: Hex;
+}
+/** Args of {@link PermissionlessDeploy.contract}. */
+interface DeployContractArgs extends DeployArgs {
+  /** Constructor values as ABI type/value pairs. */
+  values: FunctionParams[];
+  /**
+   * @defaultValue {@link DEFAULT_DEPLOY_SALT}
+   **/
+  salt?: Hex;
+}
+/**
+ * A deploy that has been resolved against the chain but not sent.
+ *
+ * Nothing here touches a wallet: sending is left to the caller, who in a
+ * browser holds the only one. A caller that signs with viem sends
+ * {@link tx} through `sendRawTx`; one on wagmi can either do the same or call
+ * `BytecodeRepository.deploy` itself with the fields below.
+ **/
+interface PreparedDeployment {
+  contractType: string;
+  version: number;
+  owner: Address;
+  salt: Hex;
+  /** ABI-encoded constructor arguments, as the repository expects them. */
+  encodedParams: Hex;
+  /** Where CREATE2 puts the contract for this `owner`, type, args and salt. */
+  address: Address;
+  /**
+   * Whether that address already holds code. When it does, {@link tx} would
+   * revert, and the deploy the caller wanted has already happened.
+   **/
+  isAlreadyDeployed: boolean;
+  /** `BytecodeRepository.deploy(contractType, version, encodedParams, salt)`. */
+  tx: RawTx;
+}
+/**
+ * A prepared price feed deploy, plus the constructor values that were actually
+ * encoded.
+ **/
+interface PreparedPriceFeedDeployment extends PreparedDeployment {
+  /**
+   * {@link DeployPriceFeedArgs.values} after the bounds that had to be read
+   * off the chain were filled in, see
+   * {@link deriveEffectiveStalenessPeriod}. Encoding these again reproduces
+   * {@link PreparedDeployment.encodedParams} byte for byte.
+   **/
+  values: Record<string, InputValueParams>;
+}
+//#endregion
+export { DeployArgs, DeployContractArgs, DeployPriceFeedArgs, PreparedDeployment, PreparedPriceFeedDeployment };

package/dist/types/permissionless/api/errors.d.ts

@@ -0,0 +1,63 @@
+import { Address, BaseError } from "viem";
+//#region src/permissionless/api/errors.d.ts
+/**
+ * Thrown when anything is read off {@link ChainsNamespace} before
+ * {@link GearboxPermissionless.attach} has completed.
+ *
+ * The chain list is the backend's answer, so there is nothing to report until
+ * it arrives. Answering with an empty list instead would be indistinguishable
+ * from a backend that serves no chains at all.
+ **/
+declare class PermissionlessNotAttachedError extends BaseError {
+  name: string;
+  constructor();
+}
+/**
+ * Thrown when a call has to read a chain the client holds no viem client for.
+ *
+ * Either the backend does not serve the chain, or it serves one this SDK
+ * carries no definition for: endpoints come from the chain definition, since
+ * the backend's own urls carry provider keys and are never handed out.
+ **/
+declare class PermissionlessChainUnreachableError extends BaseError {
+  name: string;
+  /** Chain that was asked for. */
+  readonly chainId: number;
+  constructor(chainId: number);
+}
+/**
+ * Thrown when a rename names a feed the PriceFeedStore does not carry. A name
+ * is part of what the store holds, so there is nothing to change on a feed
+ * that never reached it.
+ **/
+declare class PriceFeedNotInStoreError extends BaseError {
+  name: string;
+  /** Feed that was named. */
+  readonly priceFeed: Address;
+  readonly chainId: number;
+  constructor(priceFeed: Address, chainId: number);
+}
+/**
+ * Thrown when a composite feed names a leg whose own staleness bound cannot be
+ * read off the chain.
+ *
+ * Deploying with a placeholder is not an option: a composite whose check can
+ * never pass reverts on every read, and the store will not take it. The bound
+ * has to be set on the leg first.
+ **/
+declare class PriceFeedStalenessUnknownError extends BaseError {
+  name: string;
+  /** Leg whose bound could not be determined. */
+  readonly priceFeed: Address;
+  constructor(priceFeed: Address);
+}
+/**
+ * Thrown when a price feed deploy names neither a salt nor the name one would
+ * be derived from, leaving CREATE2 nothing to distinguish it by.
+ **/
+declare class PriceFeedSaltMissingError extends BaseError {
+  name: string;
+  constructor();
+}
+//#endregion
+export { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError };

package/dist/types/permissionless/api/index.d.ts

@@ -0,0 +1,17 @@
+import { GearboxPermissionlessOptions } from "./types.js";
+import { AttachChainsArgs, ChainScope, ChainSummaryArgs, PermissionlessChain, PermissionlessChainSummary } from "./chains/types.js";
+import { ChainsNamespace } from "./chains/ChainsNamespace.js";
+import { DeployArgs, DeployContractArgs, DeployPriceFeedArgs, PreparedDeployment, PreparedPriceFeedDeployment } from "./deploy/types.js";
+import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./deploy/PermissionlessDeploy.js";
+import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedStatus, PermissionlessPriceFeedStore, PermissionlessPrices } from "./oracles/types.js";
+import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
+import { ChangeNamesArgs, ChangeStalenessPeriodsArgs, ForbidFeedsArgs, InstanceTxsArgs } from "./transactions/types.js";
+import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransactions.js";
+import { GearboxPermissionless } from "./GearboxPermissionless.js";
+import "./chains/index.js";
+import { deriveEffectiveStalenessPeriod } from "./deploy/effective-staleness.js";
+import "./deploy/index.js";
+import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./errors.js";
+import "./oracles/index.js";
+import "./transactions/index.js";
+export { AttachChainsArgs, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, DEFAULT_DEPLOY_SALT, DeployArgs, DeployContractArgs, DeployPriceFeedArgs, ForbidFeedsArgs, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GetPricesArgs, InstanceOwnerTransactions, InstanceTxsArgs, PermissionlessAsset, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedStatus, PermissionlessPriceFeedStore, PermissionlessPrices, PreparedDeployment, PreparedPriceFeedDeployment, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };

package/dist/types/permissionless/api/oracles/PermissionlessOracles.d.ts

@@ -0,0 +1,64 @@
+import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
+import { GearboxPermissionlessOptions } from "../types.js";
+import { ChainsNamespace } from "../chains/ChainsNamespace.js";
+import { GetPricesArgs, PermissionlessPriceFeedStore, PermissionlessPrices } from "./types.js";
+import { Address } from "viem";
+//#region src/permissionless/api/oracles/PermissionlessOracles.d.ts
+declare const GET_PRICES_GAS_LIMIT_BY_CHAIN_ID: Record<number, bigint>;
+declare const GET_PRICES_CHUNK_SIZE = 200;
+/**
+ * The price feeds of one chain: the PriceFeedStore as the backend has indexed
+ * it, and the prices behind it.
+ *
+ * ```ts
+ * const store = await permissionless.oracles.store({ chainId: 1 });
+ * const { prices } = await permissionless.oracles.prices({ chainId: 1 });
+ * ```
+ *
+ * Read-only. What the store carries is decided on chain, so putting a feed
+ * there is a batch the instance owner executes — see
+ * {@link InstanceOwnerTransactions} — not a row a client writes here.
+ **/
+declare class PermissionlessOracles extends AbstractOffchainNamespace {
+  #private;
+  constructor(options: GearboxPermissionlessOptions, chains: ChainsNamespace);
+  /**
+   * The store with the assets and feeds of one chain.
+   **/
+  store({ chainId }: {
+    chainId: number;
+  }): Promise<PermissionlessPriceFeedStore>;
+  /**
+   * A price per feed, and a market cap per feed and asset. The feeds the
+   * indexer has not seen are read off the chain by the backend, so the store
+   * is priced whole.
+   **/
+  prices({ chainId }: {
+    chainId: number;
+  }): Promise<PermissionlessPrices>;
+  /**
+   * The price each of the named feeds reports, read off the chain.
+   *
+   * Where {@link prices} answers for the store as a whole and at whatever
+   * moment the backend priced it, this prices exactly the feeds asked for, at
+   * the current block. A feed the store does not carry prices the same way,
+   * which is what makes this the call to reach for after a deploy, or while a
+   * form is still choosing between candidates.
+   *
+   * Feeds needing a fresh answer before they can be read are updated inside
+   * the same simulation, so a push-based feed prices as readily as a
+   * pull-based one. `null` is a feed whose read reverted, not a zero.
+   *
+   * ```ts
+   * const prices = await permissionless.oracles.getPrices({
+   *   chainId: 1,
+   *   priceFeeds: [feed],
+   * });
+   * ```
+   *
+   * @returns A price per feed, in the 8 decimals every Gearbox feed reports.
+   **/
+  getPrices({ chainId, priceFeeds }: GetPricesArgs): Promise<Record<Address, bigint | null>>;
+}
+//#endregion
+export { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles };

package/dist/types/permissionless/api/oracles/index.d.ts

@@ -0,0 +1,3 @@
+import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedStatus, PermissionlessPriceFeedStore, PermissionlessPrices } from "./types.js";
+import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./PermissionlessOracles.js";
+export { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GetPricesArgs, PermissionlessAsset, PermissionlessOracles, PermissionlessPriceFeedStatus, PermissionlessPriceFeedStore, PermissionlessPrices };

package/dist/types/permissionless/api/oracles/schemas.d.ts

@@ -0,0 +1,103 @@
+import { z } from "zod/v4";
+//#region src/permissionless/api/oracles/schemas.d.ts
+/**
+ * Runtime schemas for {@link ./types.js}.
+ *
+ * The objects are loose: the backend reads most of these rows straight off the
+ * chain through the SDK's own bindings, which attach fields the hand-written
+ * types do not declare, and dropping them would make this client lossier than
+ * the payload it decodes.
+ **/
+/** {@link PriceFeed}, as the backend serves it. */
+declare const priceFeedSchema: z.ZodObject<{
+  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  contractType: z.ZodString;
+  version: z.ZodNumber;
+  deployedBy: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  isInStore: z.ZodBoolean;
+  stalenessPeriod: z.ZodNumber;
+  name: z.ZodString;
+}, z.core.$loose>;
+/** {@link PermissionlessPriceFeedStatus} */
+declare const priceFeedStatusSchema: z.ZodEnum<{
+  forbidden: "forbidden";
+  inStore: "inStore";
+  pendingForbidden: "pendingForbidden";
+  private: "private";
+}>;
+/** {@link PermissionlessAsset} */
+declare const assetSchema: z.ZodObject<{
+  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  symbol: z.ZodString;
+  name: z.ZodString;
+  decimals: z.ZodNumber;
+  isInStore: z.ZodBoolean;
+  owner: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  priceFeeds: z.ZodArray<z.ZodObject<{
+    pricefeed: z.ZodObject<{
+      address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+      contractType: z.ZodString;
+      version: z.ZodNumber;
+      deployedBy: z.ZodCustom<`0x${string}`, `0x${string}`>;
+      isInStore: z.ZodBoolean;
+      stalenessPeriod: z.ZodNumber;
+      name: z.ZodString;
+    }, z.core.$loose>;
+    status: z.ZodEnum<{
+      forbidden: "forbidden";
+      inStore: "inStore";
+      pendingForbidden: "pendingForbidden";
+      private: "private";
+    }>;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+/** {@link PermissionlessPriceFeedStore} */
+declare const priceFeedStoreSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  name: z.ZodString;
+  isPublic: z.ZodBoolean;
+  isActivated: z.ZodBoolean;
+  explorerUrl: z.ZodString;
+  assets: z.ZodArray<z.ZodObject<{
+    address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    isInStore: z.ZodBoolean;
+    owner: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    priceFeeds: z.ZodArray<z.ZodObject<{
+      pricefeed: z.ZodObject<{
+        address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        contractType: z.ZodString;
+        version: z.ZodNumber;
+        deployedBy: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        isInStore: z.ZodBoolean;
+        stalenessPeriod: z.ZodNumber;
+        name: z.ZodString;
+      }, z.core.$loose>;
+      status: z.ZodEnum<{
+        forbidden: "forbidden";
+        inStore: "inStore";
+        pendingForbidden: "pendingForbidden";
+        private: "private";
+      }>;
+    }, z.core.$loose>>;
+  }, z.core.$loose>>;
+  priceFeeds: z.ZodArray<z.ZodObject<{
+    address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    contractType: z.ZodString;
+    version: z.ZodNumber;
+    deployedBy: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    isInStore: z.ZodBoolean;
+    stalenessPeriod: z.ZodNumber;
+    name: z.ZodString;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+/** {@link PermissionlessPrices} */
+declare const pricesSchema: z.ZodObject<{
+  prices: z.ZodType<Record<`0x${string}`, string | null>, unknown, z.core.$ZodTypeInternals<Record<`0x${string}`, string | null>, unknown>>;
+  marketCaps: z.ZodType<Record<`0x${string}`, Record<`0x${string}`, string | null>>, unknown, z.core.$ZodTypeInternals<Record<`0x${string}`, Record<`0x${string}`, string | null>>, unknown>>;
+  time: z.ZodNumber;
+}, z.core.$loose>;
+//#endregion
+export { assetSchema, priceFeedSchema, priceFeedStatusSchema, priceFeedStoreSchema, pricesSchema };