@gearbox-protocol/sdk 17.10.1 → 17.12.0

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, PermissionlessPriceFeedStore, PermissionlessPrices } from "./oracles/types.js";
+import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
+import { AddFeedsArgs, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ForbidFeedsArgs, InstanceTxsArgs, PriceFeedPair } 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 { AddFeedsArgs, 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, PermissionlessPriceFeedStore, PermissionlessPrices, PreparedDeployment, PreparedPriceFeedDeployment, PriceFeedNotInStoreError, PriceFeedPair, 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, 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, PermissionlessPriceFeedStore, PermissionlessPrices };

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

@@ -0,0 +1,74 @@
+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}`>;
+  stalenessPeriod: z.ZodNumber;
+  name: z.ZodString;
+}, z.core.$loose>;
+/** {@link PermissionlessAsset} */
+declare const assetSchema: z.ZodObject<{
+  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  symbol: z.ZodString;
+  name: z.ZodString;
+  decimals: z.ZodNumber;
+  owner: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  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}`>;
+    stalenessPeriod: z.ZodNumber;
+    name: z.ZodString;
+  }, 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;
+    owner: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    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}`>;
+      stalenessPeriod: z.ZodNumber;
+      name: z.ZodString;
+    }, 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}`>;
+    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, priceFeedStoreSchema, pricesSchema };

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

@@ -0,0 +1,51 @@
+import { PriceFeed } from "../../core/pricefeed.js";
+import "../../core/index.js";
+import { Address } from "viem";
+//#region src/permissionless/api/oracles/types.d.ts
+/**
+ * One asset of a chain, with the feeds allowed for it. The backend indexes
+ * the chain, so every feed listed here is one the PriceFeedStore carries and
+ * allows for the asset.
+ **/
+interface PermissionlessAsset {
+  address: Address;
+  symbol: string;
+  name: string;
+  decimals: number;
+  owner: Address;
+  priceFeeds: PriceFeed[];
+}
+/**
+ * The PriceFeedStore of one chain as the backend has indexed it: the assets
+ * it prices, the feeds it carries, and which feed is allowed on which asset.
+ **/
+interface PermissionlessPriceFeedStore {
+  chainId: number;
+  name: string;
+  isPublic: boolean;
+  isActivated: boolean;
+  explorerUrl: string;
+  assets: PermissionlessAsset[];
+  priceFeeds: PriceFeed[];
+}
+/**
+ * A price per feed, and a market cap per feed and the asset it prices.
+ * `null` is a price the backend could not read, not a zero.
+ **/
+interface PermissionlessPrices {
+  prices: Record<Address, string | null>;
+  marketCaps: Record<Address, Record<Address, string | null>>;
+  time: number;
+}
+/** Args of {@link PermissionlessOracles.getPrices}. */
+interface GetPricesArgs {
+  chainId: number;
+  /**
+   * The feeds to price. Any address answering `latestRoundData` works — the
+   * store does not have to carry it, which is the point of reading the chain
+   * rather than asking the backend.
+   **/
+  priceFeeds: Address[];
+}
+//#endregion
+export { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedStore, PermissionlessPrices };

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

@@ -0,0 +1,22 @@
+import { Address } from "viem";
+import { z } from "zod/v4";
+//#region src/permissionless/api/schemas.d.ts
+/**
+ * Runtime schemas shared by the {@link GearboxPermissionless} namespaces.
+ *
+ * Addresses are validated but never rewritten: the backend serves them in the
+ * case its database holds, and its payloads key records by address, so
+ * checksumming here would silently break a lookup by the key it answered with.
+ * A caller that needs one form converts with viem's `getAddress`.
+ **/
+/** An address, in whatever case the backend serves it. */
+declare const addressSchema: z.ZodCustom<`0x${string}`, `0x${string}`>;
+/** A `0x`-prefixed hex string, as viem's `Hex`. */
+declare const hexSchema: z.ZodCustom<`0x${string}`, `0x${string}`>;
+/**
+ * A record keyed by address. Spelled out here because zod types a record key
+ * by the schema's output, which the branded `Address` is not inferred as.
+ **/
+declare function addressRecord<V extends z.ZodType>(value: V): z.ZodType<Record<Address, z.output<V>>>;
+//#endregion
+export { addressRecord, addressSchema, hexSchema };

package/dist/types/permissionless/api/transactions/InstanceOwnerTransactions.d.ts

@@ -0,0 +1,68 @@
+import { ChainsNamespace } from "../chains/ChainsNamespace.js";
+import { PermissionlessOracles } from "../oracles/PermissionlessOracles.js";
+import { InstanceTxs } from "../../utils/governance/types.js";
+import { AddFeedsArgs, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ForbidFeedsArgs, InstanceTxsArgs } from "./types.js";
+//#region src/permissionless/api/transactions/InstanceOwnerTransactions.d.ts
+/**
+ * The Safe batches an instance owner executes to apply what a curator
+ * prepared: adding their private feeds to the PriceFeedStore, renaming feeds,
+ * changing staleness periods, forbidding feeds and refreshing LP bounds.
+ *
+ * Every batch is wrapped with `wrapConfigureLocal`, so the InstanceManager is
+ * the only caller the PriceFeedStore ever sees.
+ *
+ * Backend-free: a batch is built off the chain it will be executed on, and
+ * the store it reads is the one {@link PermissionlessOracles} already
+ * fetched. Nothing is sent either — a curator never executes these
+ * themselves. They prepare a batch and hand it to the instance owner, who
+ * reviews and executes it from their Safe.
+ *
+ * ```ts
+ * const txs = await permissionless.transactions.addFeeds({
+ *   chainId: 1,
+ *   owner: curator,
+ *   feeds: [feed],
+ *   pairs: [{ asset, priceFeed: feed.address }],
+ * });
+ * ```
+ **/
+declare class InstanceOwnerTransactions {
+  #private;
+  constructor(chains: ChainsNamespace, oracles: PermissionlessOracles);
+  /**
+   * The batch that adds the named feeds to the store and allows the named
+   * edges on it.
+   *
+   * Both lists come from the caller. Which feeds are private, and which asset
+   * each is meant to price, is held wherever the curator prepared them — the
+   * backend indexes the store, so a feed that has not reached it yet is not
+   * something this client can discover.
+   *
+   * Only feeds that actually carry an edge are added: a feed nobody priced
+   * would land in the store doing nothing.
+   **/
+  addFeeds({ chainId, owner, feeds, pairs }: AddFeedsArgs): Promise<InstanceTxs>;
+  /**
+   * The batch that renames feeds already in the store. A name is part of what
+   * the store holds, so changing one is a remove and a fresh add, followed by
+   * allowing the feed again on every asset that priced it.
+   **/
+  changeNames({ chainId, owner, names }: ChangeNamesArgs): Promise<InstanceTxs>;
+  /**
+   * The batch that changes how long each feed's price stays valid.
+   **/
+  changeStalenessPeriods({ chainId, owner, periods }: ChangeStalenessPeriodsArgs): Promise<InstanceTxs>;
+  /**
+   * The batch that forbids feeds on the assets they were allowed for.
+   **/
+  forbidFeeds({ chainId, owner, tokens }: ForbidFeedsArgs): Promise<InstanceTxs>;
+  /**
+   * The batch that pulls every drifted LP feed's lower bound back under its
+   * exchange rate. Unlike the others this takes no input: the whole store is
+   * scanned and only the feeds that drifted produce a transaction, so this
+   * one is slow.
+   **/
+  updateBounds({ chainId, owner }: InstanceTxsArgs): Promise<InstanceTxs>;
+}
+//#endregion
+export { InstanceOwnerTransactions };

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

@@ -0,0 +1,3 @@
+import { AddFeedsArgs, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ForbidFeedsArgs, InstanceTxsArgs, PriceFeedPair } from "./types.js";
+import { InstanceOwnerTransactions } from "./InstanceOwnerTransactions.js";
+export { AddFeedsArgs, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ForbidFeedsArgs, InstanceOwnerTransactions, InstanceTxsArgs, PriceFeedPair };

package/dist/types/permissionless/api/transactions/lp-price-feeds.d.ts

@@ -0,0 +1,17 @@
+import { RawTx } from "../../../onchain/types/transactions.js";
+import "../../../onchain/index.js";
+import { Address, PublicClient } from "viem";
+//#region src/permissionless/api/transactions/lp-price-feeds.d.ts
+/**
+ * Moves an LP feed's lower bound back under its current exchange rate, when
+ * the rate has outgrown the bound or drifted far enough from it to be worth a
+ * transaction. Returns nothing when the bound still fits.
+ **/
+declare function updateBounds(client: PublicClient, address: Address): Promise<RawTx[]>;
+/**
+ * Of the whole feed tree behind `feeds`, the ones that are LP feeds: the
+ * probe keeps whatever answers `getLPExchangeRate`.
+ **/
+declare function getFeedsToUpdate(client: PublicClient, pfCompressor: Address, feeds: Address[]): Promise<Address[]>;
+//#endregion
+export { getFeedsToUpdate, updateBounds };

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

@@ -0,0 +1,58 @@
+import { PriceFeed } from "../../core/pricefeed.js";
+import { Address } from "viem";
+//#region src/permissionless/api/transactions/types.d.ts
+/**
+ * What every batch of {@link InstanceOwnerTransactions} names.
+ *
+ * The chain must be one {@link ChainsNamespace} serves a client for: a batch
+ * is built off the chain it will be executed on.
+ **/
+interface InstanceTxsArgs {
+  chainId: number;
+  /**
+   * Whose rows the batch is built from, and who it records as its author.
+   *
+   * Required: unlike the backend routes this replaced, nothing here carries
+   * an identity of its own, so the caller names the curator whose feeds and
+   * connections the batch applies.
+   **/
+  owner: Address;
+}
+/**
+ * One asset-to-feed edge the store has to carry, see
+ * {@link AddFeedsArgs.pairs}.
+ **/
+interface PriceFeedPair {
+  asset: Address;
+  priceFeed: Address;
+}
+/** Args of {@link InstanceOwnerTransactions.addFeeds}. */
+interface AddFeedsArgs extends InstanceTxsArgs {
+  /**
+   * The feeds to put in the store. Only what the store records is read, so a
+   * caller holding a whole {@link PriceFeed} passes it unchanged.
+   **/
+  feeds: Array<Pick<PriceFeed, "address" | "stalenessPeriod" | "name">>;
+  /**
+   * The edges to allow. Independent of {@link feeds}: an edge may name a feed
+   * the store already carries, which is allowed without adding it again.
+   **/
+  pairs: PriceFeedPair[];
+}
+/** Args of {@link InstanceOwnerTransactions.changeNames}. */
+interface ChangeNamesArgs extends InstanceTxsArgs {
+  /** The new name of each feed, keyed by the feed's address. */
+  names: Record<Address, string>;
+}
+/** Args of {@link InstanceOwnerTransactions.changeStalenessPeriods}. */
+interface ChangeStalenessPeriodsArgs extends InstanceTxsArgs {
+  /** The new staleness period in seconds, keyed by the feed's address. */
+  periods: Record<Address, number>;
+}
+/** Args of {@link InstanceOwnerTransactions.forbidFeeds}. */
+interface ForbidFeedsArgs extends InstanceTxsArgs {
+  /** The feeds to forbid, keyed by the asset they were allowed for. */
+  tokens: Record<Address, Address[]>;
+}
+//#endregion
+export { AddFeedsArgs, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ForbidFeedsArgs, InstanceTxsArgs, PriceFeedPair };

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

@@ -0,0 +1,12 @@
+import { GearboxAPIOptions } from "../../offchain/types.js";
+//#region src/permissionless/api/types.d.ts
+/**
+ * Options for creating a {@link GearboxPermissionless} instance.
+ *
+ * The same options {@link GearboxAPI} takes, since both clients read the same
+ * backend, minus the chains: those the permissionless backend decides, and
+ * {@link ChainsNamespace} reads that list and builds the clients from it.
+ **/
+type GearboxPermissionlessOptions = Omit<GearboxAPIOptions, "chainIds">;
+//#endregion
+export { GearboxPermissionlessOptions };

package/dist/types/permissionless/bindings/factory/credit-factory.d.ts

@@ -1,5 +1,5 @@
-import { AbstractFactory } from "./abstract-factory.js";
 import { DeployParams, SetExpirationDateParams, SetFeesParams } from "../types.js";
+import { AbstractFactory } from "./abstract-factory.js";
 import { Address, Hex } from "viem";
 //#region src/permissionless/bindings/factory/credit-factory.d.ts
 declare const abi: readonly [{

package/dist/types/permissionless/bindings/factory/loss-policy-factory.d.ts

@@ -1,5 +1,5 @@
-import { AbstractFactory } from "./abstract-factory.js";
 import { AccessMode } from "../types.js";
+import { AbstractFactory } from "./abstract-factory.js";
 import { Hex } from "viem";
 //#region src/permissionless/bindings/factory/loss-policy-factory.d.ts
 declare const abi: readonly [{

package/dist/types/permissionless/bindings/factory/pool-factory.d.ts

@@ -1,5 +1,5 @@
-import { AbstractFactory } from "./abstract-factory.js";
 import { SetTokenQuotaIncreaseFeeParams } from "../types.js";
+import { AbstractFactory } from "./abstract-factory.js";
 import { Address, Hex } from "viem";
 //#region src/permissionless/bindings/factory/pool-factory.d.ts
 declare const abi: readonly [{

package/dist/types/permissionless/bindings/factory/price-oracle-factory.d.ts

@@ -1,5 +1,5 @@
-import { AbstractFactory } from "./abstract-factory.js";
 import { SetPriceFeedParams, SetReservePriceFeedParams } from "../types.js";
+import { AbstractFactory } from "./abstract-factory.js";
 import { Hex } from "viem";
 //#region src/permissionless/bindings/factory/price-oracle-factory.d.ts
 declare const abi: readonly [{

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

@@ -4,12 +4,12 @@ import { TokenCompressorContract } from "./compressors/token-compressor.js";
 import { WithdrawalCompressorContract } from "./compressors/withdrawal-compressor.js";
 import "./compressors/index.js";
 import { ConstructorParams, CrossChainMultisigContract, Proposal } from "./cross-chain-multisig.js";
-import { AccessMode, AddAssetParams, AllowTokenParams, CreditManagerFees, DeployParams, ForbidAdapterParams, ForbidTokenParams, Market, PauseCreditManagerParams, PeripheryDomain, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, UnpauseCreditManagerParams } from "./types.js";
 import { QueuedAndExecutedTransaction, SafeBatch, SafeMeta, SafeTx, TimelockTransaction, TimelockTxParams } from "./governance/types.js";
 import { GovernorContract } from "./governance/governor.js";
 import { TimeLockContract } from "./governance/timelock.js";
 import "./governance/index.js";
 import { InstanceManagerContract } from "./instance-manager.js";
+import { AccessMode, AddAssetParams, AllowTokenParams, CreditManagerFees, DeployParams, ForbidAdapterParams, ForbidTokenParams, Market, PauseCreditManagerParams, PeripheryDomain, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, UnpauseCreditManagerParams } from "./types.js";
 import { MarketConfiguratorContract } from "./market-configurator.js";
 import { MarketConfiguratorFactoryContract } from "./market-configurator-factory.js";
 import { PriceFeedStoreContract } from "./price-feed-store.js";

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

@@ -1,7 +1,7 @@
 import { Auditor } from "./auditor.js";
 import { AuditEvent, Bytecode, Deployment, DeploymentExtended } from "./bytecode.js";
-import { Batch, CrossChainCall, RecoveryMessage, Signature } from "./proposal.js";
 import { PriceFeed } from "./pricefeed.js";
 import { InputValueParams, PriceFeedConstructorParam, PriceFeedParamType, PriceFeedParams, PriceFeedSetupParams } from "./pricefeed-builder.js";
+import { Batch, CrossChainCall, RecoveryMessage, Signature } from "./proposal.js";
 import { createCallData } from "./raw-tx.js";
 export { AuditEvent, Auditor, Batch, Bytecode, CrossChainCall, Deployment, DeploymentExtended, InputValueParams, PriceFeed, PriceFeedConstructorParam, PriceFeedParamType, PriceFeedParams, PriceFeedSetupParams, RecoveryMessage, Signature, createCallData };

package/dist/types/permissionless/core/pricefeed.d.ts

@@ -5,7 +5,6 @@ interface PriceFeed {
   contractType: string;
   version: number;
   deployedBy: Address;
-  isInStore: boolean;
   stalenessPeriod: number;
   name: string;
 }

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

@@ -1,42 +1,55 @@
-import { AddressProviderContract } from "./bindings/address-provider.js";
+import { GearboxPermissionlessOptions } from "./api/types.js";
+import { AttachChainsArgs, ChainScope, ChainSummaryArgs, PermissionlessChain, PermissionlessChainSummary } from "./api/chains/types.js";
+import { ChainsNamespace } from "./api/chains/ChainsNamespace.js";
 import { Auditor } from "./core/auditor.js";
 import { AuditEvent, Bytecode, Deployment, DeploymentExtended } from "./core/bytecode.js";
+import { PriceFeed } from "./core/pricefeed.js";
+import { InputValueParams, PriceFeedConstructorParam, PriceFeedParamType, PriceFeedParams, PriceFeedSetupParams } from "./core/pricefeed-builder.js";
+import { Batch, CrossChainCall, RecoveryMessage, Signature } from "./core/proposal.js";
+import { createCallData } from "./core/raw-tx.js";
+import "./core/index.js";
+import { FunctionParams, ValueParams, encodeFunctionParams } from "./utils/abi-encoder.js";
+import { DeployArgs, DeployContractArgs, DeployPriceFeedArgs, PreparedDeployment, PreparedPriceFeedDeployment } from "./api/deploy/types.js";
+import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./api/deploy/PermissionlessDeploy.js";
+import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedStore, PermissionlessPrices } from "./api/oracles/types.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 { BytecodeRepositoryContract } from "./bindings/bytecode-repository.js";
 import { TokenCompressorContract } from "./bindings/compressors/token-compressor.js";
 import { WithdrawalCompressorContract } from "./bindings/compressors/withdrawal-compressor.js";
-import { Batch, CrossChainCall, RecoveryMessage, Signature } from "./core/proposal.js";
 import { ConstructorParams, CrossChainMultisigContract, Proposal } from "./bindings/cross-chain-multisig.js";
-import { AccessMode, AddAssetParams, AllowTokenParams, CreditManagerFees, DeployParams, ForbidAdapterParams, ForbidTokenParams, Market, PauseCreditManagerParams, PeripheryDomain, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, UnpauseCreditManagerParams } from "./bindings/types.js";
 import { QueuedAndExecutedTransaction, SafeBatch, SafeMeta, SafeTx, TimelockTransaction, TimelockTxParams } from "./bindings/governance/types.js";
 import { GovernorContract } from "./bindings/governance/governor.js";
 import { TimeLockContract } from "./bindings/governance/timelock.js";
 import { InstanceManagerContract } from "./bindings/instance-manager.js";
+import { AccessMode, AddAssetParams, AllowTokenParams, CreditManagerFees, DeployParams, ForbidAdapterParams, ForbidTokenParams, Market, PauseCreditManagerParams, PeripheryDomain, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, UnpauseCreditManagerParams } from "./bindings/types.js";
 import { MarketConfiguratorContract } from "./bindings/market-configurator.js";
 import { MarketConfiguratorFactoryContract } from "./bindings/market-configurator-factory.js";
-import { PriceFeed } from "./core/pricefeed.js";
-import { InputValueParams, PriceFeedConstructorParam, PriceFeedParamType, PriceFeedParams, PriceFeedSetupParams } from "./core/pricefeed-builder.js";
-import { createCallData } from "./core/raw-tx.js";
-import "./core/index.js";
 import { PriceFeedStoreContract } from "./bindings/price-feed-store.js";
 import { priceFeedSetupParams } from "./bindings/pricefeeds/index.js";
 import { RoutingManagerContract } from "./bindings/router/routing-manager.js";
 import { TreasurySplitterContract } from "./bindings/treasury-splitter.js";
 import "./bindings/index.js";
+import { InstanceTxs, TimelockTxs } from "./utils/governance/types.js";
+import { AddFeedsArgs, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ForbidFeedsArgs, InstanceTxsArgs, PriceFeedPair } from "./api/transactions/types.js";
+import { InstanceOwnerTransactions } from "./api/transactions/InstanceOwnerTransactions.js";
+import { GearboxPermissionless } from "./api/GearboxPermissionless.js";
+import { deriveEffectiveStalenessPeriod } from "./api/deploy/effective-staleness.js";
+import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./api/errors.js";
+import "./api/index.js";
 import { ArchiveTransport, ArchiveTransportConfig } from "./chains/archive-transport.js";
 import { chunkedLogsTransport } from "./chains/chunked-log-transport.js";
 import { Addresses } from "./deployment/addresses.js";
 import { CCMConstructorParams, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT } from "./deployment/mainnet.js";
-import { FunctionParams, ValueParams, encodeFunctionParams } from "./utils/abi-encoder.js";
 import { getBlockNumberByTimestamp } from "./utils/block-utils.js";
 import { PUBLIC_CREATE2_FACTORY, checkCreate2Deployment, checkCreate2DeploymentAddress, createCreate2DeployRawTx, deployUsingPublicCreate2, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, handleSalt } from "./utils/create2.js";
 import { convertPercent, deepJsonParse, formatBytecodeSize, formatBytecodeVersion, shortenHash, significantTrunc } from "./utils/format.js";
 import { calculateChecksum, convertRawTxToSafeMultisigTx, getSafeBatch, getSafeBatches } from "./utils/governance/batch.js";
 import { convertQueueBatchToExecuteTx } from "./utils/governance/timelock-txs.js";
-import { InstanceTxs, TimelockTxs } from "./utils/governance/types.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 { getPriceUpdateTx } from "./utils/price-update/get-price-update-tx.js";
 import { getPrices } from "./utils/price-update/get-prices.js";
 import { GetUpdatablePriceFeedsArgs, getUpdatablePriceFeeds } from "./utils/price-update/get-updatable-feeds.js";
 import { normalizeSignature } from "./utils/signature.js";
 import "./utils/index.js";
-export { AccessMode, AddAssetParams, AddressProviderContract, Addresses, AllowTokenParams, ArchiveTransport, ArchiveTransportConfig, AuditEvent, Auditor, BYTECODE_REPOSITORY, Batch, Bytecode, BytecodeRepositoryContract, CCMConstructorParams, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ConstructorParams, CreditManagerFees, CrossChainCall, CrossChainMultisigContract, DeployParams, Deployment, DeploymentExtended, ForbidAdapterParams, ForbidTokenParams, FunctionParams, GetUpdatablePriceFeedsArgs, GovernorContract, INSTANCE_MANAGER, InputValueParams, InstanceManagerContract, InstanceTxs, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, Market, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PauseCreditManagerParams, PeripheryDomain, PriceFeed, PriceFeedConstructorParam, PriceFeedParamType, PriceFeedParams, PriceFeedSetupParams, PriceFeedStoreContract, Proposal, QueuedAndExecutedTransaction, RecoveryMessage, RoutingManagerContract, SafeBatch, SafeMeta, SafeTx, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, Signature, TOKEN_COMPRESSOR, TimeLockContract, TimelockTransaction, TimelockTxParams, TimelockTxs, TokenCompressorContract, TreasurySplitterContract, UnpauseCreditManagerParams, ValueParams, 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, AddAssetParams, AddFeedsArgs, AddressProviderContract, Addresses, AllowTokenParams, ArchiveTransport, ArchiveTransportConfig, AttachChainsArgs, AuditEvent, Auditor, BYTECODE_REPOSITORY, Batch, Bytecode, BytecodeRepositoryContract, CCMConstructorParams, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ConstructorParams, CreditManagerFees, CrossChainCall, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, DeployArgs, DeployContractArgs, DeployParams, DeployPriceFeedArgs, Deployment, DeploymentExtended, ForbidAdapterParams, ForbidFeedsArgs, ForbidTokenParams, FunctionParams, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GetPricesArgs, GetUpdatablePriceFeedsArgs, GovernorContract, INSTANCE_MANAGER, InputValueParams, InstanceManagerContract, InstanceOwnerTransactions, InstanceTxs, InstanceTxsArgs, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, Market, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PauseCreditManagerParams, PeripheryDomain, PermissionlessAsset, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedStore, PermissionlessPrices, PreparedDeployment, PreparedPriceFeedDeployment, PriceFeed, PriceFeedConstructorParam, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedParamType, PriceFeedParams, PriceFeedSaltMissingError, PriceFeedSetupParams, PriceFeedStalenessUnknownError, PriceFeedStoreContract, Proposal, QueuedAndExecutedTransaction, RecoveryMessage, RoutingManagerContract, SafeBatch, SafeMeta, SafeTx, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, Signature, TOKEN_COMPRESSOR, TimeLockContract, TimelockTransaction, TimelockTxParams, TimelockTxs, TokenCompressorContract, TreasurySplitterContract, UnpauseCreditManagerParams, ValueParams, 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/types/permissionless/utils/governance/index.d.ts

@@ -1,4 +1,4 @@
+import { InstanceTxs, TimelockTxs } from "./types.js";
 import { calculateChecksum, convertRawTxToSafeMultisigTx, getSafeBatch, getSafeBatches } from "./batch.js";
 import { convertQueueBatchToExecuteTx } from "./timelock-txs.js";
-import { InstanceTxs, TimelockTxs } from "./types.js";
 export { InstanceTxs, TimelockTxs, calculateChecksum, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, getSafeBatch, getSafeBatches };

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

@@ -1,10 +1,10 @@
 import { FunctionParams, ValueParams, encodeFunctionParams } from "./abi-encoder.js";
+import { InstanceTxs, TimelockTxs } from "./governance/types.js";
 import { getBlockNumberByTimestamp } from "./block-utils.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 { calculateChecksum, convertRawTxToSafeMultisigTx, getSafeBatch, getSafeBatches } from "./governance/batch.js";
 import { convertQueueBatchToExecuteTx } from "./governance/timelock-txs.js";
-import { InstanceTxs, TimelockTxs } from "./governance/types.js";
 import "./governance/index.js";
 import { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, MARKET_CONFIGURATOR_FACTORY, PRICE_FEED_STORE, TOKEN_COMPRESSOR } from "./literals.js";
 import { getPriceUpdateTx } from "./price-update/get-price-update-tx.js";