@gearbox-protocol/sdk 17.10.1 → 17.12.0

package/dist/esm/permissionless/bindings/instance-manager.js

@@ -3,8 +3,7 @@ import { BaseContract } from "../../onchain/base/BaseContract.js";
 import { gearboxRouterAbi } from "../../abi/router/gearboxRouter.js";
 import "../../onchain/index.js";
 import { BytecodeRepositoryContract } from "./bytecode-repository.js";
-import { WithdrawalCompressorContract } from "./compressors/withdrawal-compressor.js";
-import "./compressors/index.js";
+import { PriceFeedStoreContract } from "./price-feed-store.js";
 import "../deployment/addresses.js";
 import { instanceManagerAbi } from "../../abi/310/instanceManager.js";
 import { camelotV3WorkerAbi } from "../../abi/router/camelotV3Worker.js";
@@ -13,7 +12,8 @@ import { mellow4626WorkerAbi } from "../../abi/router/mellow4626Worker.js";
 import { pendleRouterWorkerAbi } from "../../abi/router/pendleRouterWorker.js";
 import { uniswapV3WorkerAbi } from "../../abi/router/uniswapV3Worker.js";
 import { uniswapV4WorkerAbi } from "../../abi/router/uniswapV4Worker.js";
-import { PriceFeedStoreContract } from "./price-feed-store.js";
+import { WithdrawalCompressorContract } from "./compressors/withdrawal-compressor.js";
+import "./compressors/index.js";
 import { RoutingManagerContract } from "./router/routing-manager.js";
 import "./router/index.js";
 import { TreasurySplitterContract } from "./treasury-splitter.js";

package/dist/esm/permissionless/bindings/price-feed-store.js

@@ -45,7 +45,6 @@ var PriceFeedStoreContract = class extends BaseContract {
 			deployedBy: this.address,
 			stalenessPeriod: info.stalenessPeriod,
 			name: info.name,
-			isInStore: true,
 			parameters: {}
 		}));
 	}
@@ -276,7 +275,6 @@ var PriceFeedStoreContract = class extends BaseContract {
 				deployedBy: this.address,
 				stalenessPeriod: Number(info.stalenessPeriod),
 				name: info.name,
-				isInStore: true,
 				parameters: {}
 			};
 		});

package/dist/esm/permissionless/index.js

@@ -1,15 +1,27 @@
-import { AddressProviderContract } from "./bindings/address-provider.js";
+import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./api/errors.js";
+import { ChainsNamespace } from "./api/chains/ChainsNamespace.js";
+import { deriveEffectiveStalenessPeriod } from "./api/deploy/effective-staleness.js";
 import { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, MARKET_CONFIGURATOR_FACTORY, PRICE_FEED_STORE, TOKEN_COMPRESSOR } from "./utils/literals.js";
 import { normalizeSignature } from "./utils/signature.js";
 import { BytecodeRepositoryContract } from "./bindings/bytecode-repository.js";
-import { TokenCompressorContract } from "./bindings/compressors/token-compressor.js";
-import { WithdrawalCompressorContract } from "./bindings/compressors/withdrawal-compressor.js";
-import { Addresses } from "./deployment/addresses.js";
 import { priceFeedSetupParams } from "./bindings/pricefeeds/index.js";
 import { PriceFeedStoreContract } from "./bindings/price-feed-store.js";
+import { Addresses } from "./deployment/addresses.js";
+import { encodeFunctionParams } from "./utils/abi-encoder.js";
+import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./api/deploy/PermissionlessDeploy.js";
+import { getPrices } from "./utils/price-update/get-prices.js";
+import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./api/oracles/PermissionlessOracles.js";
+import { AddressProviderContract } from "./bindings/address-provider.js";
+import { TokenCompressorContract } from "./bindings/compressors/token-compressor.js";
+import { WithdrawalCompressorContract } from "./bindings/compressors/withdrawal-compressor.js";
 import { RoutingManagerContract } from "./bindings/router/routing-manager.js";
 import { TreasurySplitterContract } from "./bindings/treasury-splitter.js";
 import { InstanceManagerContract } from "./bindings/instance-manager.js";
+import { calculateChecksum, convertRawTxToSafeMultisigTx, getSafeBatch, getSafeBatches } from "./utils/governance/batch.js";
+import { getUpdatablePriceFeeds } from "./utils/price-update/get-updatable-feeds.js";
+import { InstanceOwnerTransactions } from "./api/transactions/InstanceOwnerTransactions.js";
+import { GearboxPermissionless } from "./api/GearboxPermissionless.js";
+import "./api/index.js";
 import { MarketConfiguratorFactoryContract } from "./bindings/market-configurator-factory.js";
 import { CrossChainMultisigContract } from "./bindings/cross-chain-multisig.js";
 import { PUBLIC_CREATE2_FACTORY, checkCreate2Deployment, checkCreate2DeploymentAddress, createCreate2DeployRawTx, deployUsingPublicCreate2, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, handleSalt } from "./utils/create2.js";
@@ -24,12 +36,8 @@ import { ArchiveTransport } from "./chains/archive-transport.js";
 import { chunkedLogsTransport } from "./chains/chunked-log-transport.js";
 import "./core/index.js";
 import { MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT } from "./deployment/mainnet.js";
-import { encodeFunctionParams } from "./utils/abi-encoder.js";
 import { getBlockNumberByTimestamp } from "./utils/block-utils.js";
-import { calculateChecksum, convertRawTxToSafeMultisigTx, getSafeBatch, getSafeBatches } from "./utils/governance/batch.js";
 import { convertQueueBatchToExecuteTx } from "./utils/governance/timelock-txs.js";
 import { getPriceUpdateTx } from "./utils/price-update/get-price-update-tx.js";
-import { getPrices } from "./utils/price-update/get-prices.js";
-import { getUpdatablePriceFeeds } from "./utils/price-update/get-updatable-feeds.js";
 import "./utils/index.js";
-export { AccessMode, AddressProviderContract, Addresses, ArchiveTransport, BYTECODE_REPOSITORY, BytecodeRepositoryContract, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, CrossChainMultisigContract, GovernorContract, INSTANCE_MANAGER, InstanceManagerContract, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PriceFeedStoreContract, RoutingManagerContract, TOKEN_COMPRESSOR, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, priceFeedSetupParams, shortenHash, significantTrunc };
+export { AccessMode, AddressProviderContract, Addresses, ArchiveTransport, BYTECODE_REPOSITORY, BytecodeRepositoryContract, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainsNamespace, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GovernorContract, INSTANCE_MANAGER, InstanceManagerContract, InstanceOwnerTransactions, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, PriceFeedStoreContract, RoutingManagerContract, TOKEN_COMPRESSOR, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, priceFeedSalt, priceFeedSetupParams, shortenHash, significantTrunc };

package/dist/esm/permissionless/utils/governance/timelock-txs.js

@@ -1,7 +1,7 @@
 import { createRawTx } from "../../../onchain/utils/createRawTx.js";
 import "../../../onchain/index.js";
-import { governorAbi } from "../../../abi/governance/governor.js";
 import { convertRawTxToSafeMultisigTx } from "./batch.js";
+import { governorAbi } from "../../../abi/governance/governor.js";
 //#region src/permissionless/utils/governance/timelock-txs.ts
 function convertQueueBatchToExecuteTx(queueBatch) {
 	const executionBatch = queueBatch.filter((tx) => tx.contractMethod.name === "queueTransaction").map((tx) => ({

package/dist/esm/permissionless/utils/index.js

@@ -1,14 +1,14 @@
 import { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, MARKET_CONFIGURATOR_FACTORY, PRICE_FEED_STORE, TOKEN_COMPRESSOR } from "./literals.js";
 import { normalizeSignature } from "./signature.js";
+import { encodeFunctionParams } from "./abi-encoder.js";
+import { getPrices } from "./price-update/get-prices.js";
+import { calculateChecksum, convertRawTxToSafeMultisigTx, getSafeBatch, getSafeBatches } from "./governance/batch.js";
+import { getUpdatablePriceFeeds } from "./price-update/get-updatable-feeds.js";
 import { PUBLIC_CREATE2_FACTORY, checkCreate2Deployment, checkCreate2DeploymentAddress, createCreate2DeployRawTx, deployUsingPublicCreate2, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, handleSalt } from "./create2.js";
 import { convertPercent, deepJsonParse, formatBytecodeSize, formatBytecodeVersion, shortenHash, significantTrunc } from "./format.js";
-import { encodeFunctionParams } from "./abi-encoder.js";
 import { getBlockNumberByTimestamp } from "./block-utils.js";
-import { calculateChecksum, convertRawTxToSafeMultisigTx, getSafeBatch, getSafeBatches } from "./governance/batch.js";
 import { convertQueueBatchToExecuteTx } from "./governance/timelock-txs.js";
 import "./governance/index.js";
 import { getPriceUpdateTx } from "./price-update/get-price-update-tx.js";
-import { getPrices } from "./price-update/get-prices.js";
-import { getUpdatablePriceFeeds } from "./price-update/get-updatable-feeds.js";
 import "./price-update/index.js";
 export { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, MARKET_CONFIGURATOR_FACTORY, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, TOKEN_COMPRESSOR, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, shortenHash, significantTrunc };

package/dist/esm/permissionless/utils/price-update/get-price-update-tx.js

@@ -2,8 +2,8 @@ import { createRawTx } from "../../../onchain/utils/createRawTx.js";
 import { getRawPriceUpdates } from "../../../onchain/market/pricefeeds/updates/getRawPriceUpdates.js";
 import { OnchainSDK } from "../../../onchain/OnchainSDK.js";
 import "../../../onchain/index.js";
-import "../../deployment/addresses.js";
 import { PriceFeedStoreContract } from "../../bindings/price-feed-store.js";
+import "../../deployment/addresses.js";
 import "../../bindings/index.js";
 import { multicall3Abi } from "viem";
 //#region src/permissionless/utils/price-update/get-price-update-tx.ts

package/dist/esm/permissionless/utils/price-update/index.js

@@ -1,4 +1,4 @@
-import { getPriceUpdateTx } from "./get-price-update-tx.js";
 import { getPrices } from "./get-prices.js";
 import { getUpdatablePriceFeeds } from "./get-updatable-feeds.js";
+import { getPriceUpdateTx } from "./get-price-update-tx.js";
 export { getPriceUpdateTx, getPrices, getUpdatablePriceFeeds };

package/dist/types/offchain/AbstractOffchainNamespace.d.ts

@@ -54,6 +54,18 @@ declare abstract class AbstractOffchainNamespace {
    * schema skew throw, since none of them is a {@link DataResponse}.
    **/
   protected get<S extends z.ZodType>(request: OffchainGetRequest<S>): Promise<DataResponse<z.output<S>>>;
+  /**
+   * Reads one endpoint that answers with the payload alone, and returns it
+   * unwrapped.
+   *
+   * A read served at no particular block has no envelope to report: the
+   * permissionless routes either span every chain at once, or fall through to
+   * a multicall on the chain itself, so the backend answers `{ data }` and
+   * there is no {@link ResponseMetadata} for {@link get} to decode. The
+   * envelope is still there, which is what keeps a payload that happens to be
+   * an array from being mistaken for an error body.
+   **/
+  protected getData<S extends z.ZodType>(request: OffchainGetRequest<S>): Promise<z.output<S>>;
   /**
    * Reads the charts of one subject: one series per metric named, onto the one
    * grid that lets them be compared at an index.

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

@@ -0,0 +1,71 @@
+import { GearboxPermissionlessOptions } from "./types.js";
+import { AttachChainsArgs } from "./chains/types.js";
+import { ChainsNamespace } from "./chains/ChainsNamespace.js";
+import { PermissionlessDeploy } from "./deploy/PermissionlessDeploy.js";
+import { PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
+import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransactions.js";
+//#region src/permissionless/api/GearboxPermissionless.d.ts
+/**
+ * Client for the permissionless stack: the oracle rows of a chain, the
+ * batches an instance owner executes, and the deploys that produce what goes
+ * into both.
+ *
+ * It reads the same backend {@link GearboxAPI} does, and reads the same way —
+ * one namespace per subject, every call scoped by the chain it names. Which
+ * chains those are is not passed in: {@link attach} reads the list off the
+ * backend and builds a client for each, so this client covers exactly what
+ * the backend serves.
+ *
+ * ```ts
+ * const permissionless = new GearboxPermissionless({
+ *   baseUrl: "https://api.gearbox.fi",
+ * });
+ * await permissionless.attach();
+ *
+ * const [chain] = permissionless.chains.list();
+ * const store = await permissionless.oracles.store({ chainId: chain.chainId });
+ * ```
+ *
+ * Only what needs a server goes to one. {@link chains} and {@link oracles}
+ * are the backend's reads; {@link deploy} and {@link transactions} read the
+ * target chain directly, because everything they answer is derived from there
+ * and a round trip would only move the derivation further from the wallet
+ * that has to sign for it.
+ **/
+declare class GearboxPermissionless {
+  /**
+   * Namespace for the chains the stack runs on, and the viem clients that
+   * reach them.
+   **/
+  readonly chains: ChainsNamespace;
+  /**
+   * Namespace for price feeds: the store and its prices.
+   **/
+  readonly oracles: PermissionlessOracles;
+  /**
+   * Namespace for the Safe batches an instance owner executes. Backend-free,
+   * see {@link InstanceOwnerTransactions}.
+   **/
+  readonly transactions: InstanceOwnerTransactions;
+  /**
+   * Namespace for deploys through the BytecodeRepository. Backend-free, see
+   * {@link PermissionlessDeploy}.
+   **/
+  readonly deploy: PermissionlessDeploy;
+  constructor(options?: GearboxPermissionlessOptions);
+  /**
+   * Loads the chain list and builds the clients, see
+   * {@link ChainsNamespace.attach}. Idempotent, and joins a call already in
+   * flight.
+   *
+   * Everything that reads a chain goes through it, so this has to finish
+   * before the first such call.
+   **/
+  attach(args?: AttachChainsArgs): Promise<void>;
+  /**
+   * Whether {@link attach} has completed.
+   **/
+  get isAttached(): boolean;
+}
+//#endregion
+export { GearboxPermissionless };

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 };