@gearbox-protocol/sdk 17.10.1 → 17.11.0

package/dist/esm/permissionless/api/schemas.js

@@ -0,0 +1,25 @@
+import { isAddress, isHex } from "viem";
+import { z } from "zod/v4";
+//#region src/permissionless/api/schemas.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. */
+const addressSchema = z.custom((value) => typeof value === "string" && isAddress(value, { strict: false }), { message: "invalid address" });
+/** A `0x`-prefixed hex string, as viem's `Hex`. */
+const hexSchema = z.custom((value) => typeof value === "string" && isHex(value), { message: "invalid hex 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.
+**/
+function addressRecord(value) {
+	const key = z.string().refine((v) => isAddress(v, { strict: false }), { message: "invalid address" });
+	return z.record(key, value);
+}
+//#endregion
+export { addressRecord, addressSchema, hexSchema };

package/dist/esm/permissionless/api/transactions/InstanceOwnerTransactions.js

@@ -0,0 +1,229 @@
+import { createRawTx } from "../../../onchain/utils/createRawTx.js";
+import { getNetworkType } from "../../../onchain/chain/chains.js";
+import { AP_PRICE_FEED_COMPRESSOR } from "../../../onchain/constants/address-provider.js";
+import { VERSION_RANGE_310 } from "../../../onchain/constants/versions.js";
+import { ChainContractsRegister } from "../../../onchain/base/ChainContractsRegister.js";
+import { OnchainSDK } from "../../../onchain/OnchainSDK.js";
+import "../../../onchain/index.js";
+import { PriceFeedNotInStoreError } from "../errors.js";
+import { INSTANCE_MANAGER } from "../../utils/literals.js";
+import { PriceFeedStoreContract } from "../../bindings/price-feed-store.js";
+import "../../deployment/addresses.js";
+import { AddressProviderContract } from "../../bindings/address-provider.js";
+import { InstanceManagerContract } from "../../bindings/instance-manager.js";
+import { convertRawTxToSafeMultisigTx, getSafeBatch } from "../../utils/governance/batch.js";
+import { getUpdatablePriceFeeds } from "../../utils/price-update/get-updatable-feeds.js";
+import { getFeedsToUpdate, updateBounds } from "./lp-price-feeds.js";
+//#region src/permissionless/api/transactions/InstanceOwnerTransactions.ts
+const lower = (value) => value.toLowerCase();
+/**
+* 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,
+* });
+* ```
+**/
+var InstanceOwnerTransactions = class {
+	#chains;
+	#oracles;
+	constructor(chains, oracles) {
+		this.#chains = chains;
+		this.#oracles = oracles;
+	}
+	/**
+	* The batch that adds the owner's private feeds to the store and allows
+	* them on the assets they were connected to. Only feeds that actually carry
+	* a connection are added: a feed nobody priced would land in the store
+	* doing nothing.
+	**/
+	async addFeeds({ chainId, owner }) {
+		const [batch, store] = await Promise.all([this.#batchContext(chainId), this.#oracles.store({ chainId })]);
+		const pairs = store.assets.flatMap((asset) => asset.priceFeeds.filter((entry) => entry.status === "private").map((entry) => ({
+			asset: asset.address,
+			priceFeed: entry.pricefeed.address
+		})));
+		const connected = new Set(pairs.map((pair) => lower(pair.priceFeed)));
+		const feedsToAdd = store.priceFeeds.filter((feed) => !feed.isInStore && connected.has(lower(feed.address)));
+		const txs = [...feedsToAdd.map((feed) => batch.store.addPriceFeedTx(feed.address, feed.stalenessPeriod, feed.name)), ...pairs.map((pair) => batch.store.allowPriceFeedTx(pair.asset, pair.priceFeed))];
+		return this.#envelope({
+			batch,
+			author: owner,
+			name: "pfs-updates",
+			txs,
+			touchedFeeds: feedsToAdd.map((feed) => feed.address)
+		});
+	}
+	/**
+	* 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.
+	**/
+	async changeNames({ chainId, owner, names }) {
+		const [batch, store] = await Promise.all([this.#batchContext(chainId), this.#oracles.store({ chainId })]);
+		const feedToAssets = await this.#feedToAssets(batch.store);
+		const inStore = new Map(store.priceFeeds.filter((feed) => feed.isInStore).map((feed) => [lower(feed.address), feed]));
+		const txs = [];
+		for (const [address, name] of Object.entries(names)) {
+			const feed = inStore.get(lower(address));
+			if (!feed) throw new PriceFeedNotInStoreError(address, chainId);
+			txs.push(batch.store.removePriceFeedTx(feed.address), batch.store.addPriceFeedTx(feed.address, feed.stalenessPeriod, name));
+			for (const asset of feedToAssets.get(lower(address)) ?? []) txs.push(batch.store.allowPriceFeedTx(asset, feed.address));
+		}
+		return this.#envelope({
+			batch,
+			author: owner,
+			name: "pricefeed-name-changes",
+			txs,
+			touchedFeeds: Object.keys(names)
+		});
+	}
+	/**
+	* The batch that changes how long each feed's price stays valid.
+	**/
+	async changeStalenessPeriods({ chainId, owner, periods }) {
+		const batch = await this.#batchContext(chainId);
+		const entries = Object.entries(periods);
+		const txs = entries.map(([address, period]) => batch.store.setStalenessPeriodTx(address, period));
+		return this.#envelope({
+			batch,
+			author: owner,
+			name: "pricefeed-staleness-changes",
+			txs,
+			touchedFeeds: entries.map(([address]) => address)
+		});
+	}
+	/**
+	* The batch that forbids feeds on the assets they were allowed for.
+	**/
+	async forbidFeeds({ chainId, owner, tokens }) {
+		const batch = await this.#batchContext(chainId);
+		const txs = Object.entries(tokens).flatMap(([token, feeds]) => feeds.map((feed) => createRawTx(batch.store.address, {
+			abi: batch.store.abi,
+			functionName: "forbidPriceFeed",
+			args: [token, feed]
+		})));
+		return this.#envelope({
+			batch,
+			author: owner,
+			name: "forbid-feeds",
+			txs,
+			touchedFeeds: []
+		});
+	}
+	/**
+	* 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.
+	**/
+	async updateBounds({ chainId, owner }) {
+		const batch = await this.#batchContext(chainId);
+		const pfCompressor = await this.#priceFeedCompressor(batch.client);
+		const known = await batch.store.getKnownPriceFeeds();
+		const feeds = await getFeedsToUpdate(batch.client, pfCompressor, known);
+		const configureTxs = [];
+		for (const feed of feeds) configureTxs.push(...await updateBounds(batch.client, feed));
+		const txs = [batch.store.configurePriceFeeds(configureTxs.map((tx) => ({
+			target: tx.to,
+			callData: tx.callData
+		})))];
+		return this.#envelope({
+			batch,
+			author: owner,
+			name: "update-bounds",
+			txs,
+			touchedFeeds: []
+		});
+	}
+	/**
+	* The contracts every batch of one chain is built against.
+	*
+	* Nothing here checks that the instance is activated: that is a backend
+	* read, and an instance without a deployed InstanceManager fails on the
+	* owner lookup below anyway.
+	**/
+	async #batchContext(chainId) {
+		const client = this.#chains.client(chainId);
+		const addressProvider = new AddressProviderContract("0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38", client);
+		const instanceManager = new InstanceManagerContract(await addressProvider.getAddressOrRevert(INSTANCE_MANAGER), new ChainContractsRegister(client));
+		return {
+			chainId,
+			client,
+			store: new PriceFeedStoreContract("0x74A868AC479EE145029bB80827BB77F7B7c441cB", client),
+			instanceManager,
+			instanceOwner: await instanceManager.getOwner()
+		};
+	}
+	/** The common shape every batch is returned in. */
+	async #envelope(args) {
+		const { batch, author, name, txs, touchedFeeds } = args;
+		const { chainId, client, instanceManager, instanceOwner } = batch;
+		const wrapped = txs.map((tx) => instanceManager.wrapConfigureLocal(tx));
+		const safeBatch = getSafeBatch({
+			chainId,
+			safeAddress: instanceOwner,
+			name,
+			txs: wrapped.map((tx) => convertRawTxToSafeMultisigTx(tx))
+		});
+		const [block, updatableFeeds] = await Promise.all([client.getBlock(), this.#updatableFeeds(touchedFeeds, client)]);
+		return {
+			chainId,
+			author,
+			instanceManager: instanceManager.address,
+			batches: [safeBatch.transactions],
+			createdAtBlock: Number(block.number),
+			updatableFeeds: [updatableFeeds]
+		};
+	}
+	/** Which of the touched feeds the executor has to push a price update for. */
+	async #updatableFeeds(touchedFeeds, client) {
+		if (touchedFeeds.length === 0) return [];
+		const sdk = await this.#sdk(client);
+		return (await getUpdatablePriceFeeds({
+			sdk,
+			client,
+			pfCompressor: this.#compressorFrom(sdk),
+			priceFeeds: touchedFeeds
+		})).map((contract) => contract.address);
+	}
+	async #priceFeedCompressor(client) {
+		return this.#compressorFrom(await this.#sdk(client));
+	}
+	#compressorFrom(sdk) {
+		const [compressor] = sdk.addressProvider.mustGetLatest(AP_PRICE_FEED_COMPRESSOR, VERSION_RANGE_310);
+		return compressor;
+	}
+	async #sdk(client) {
+		const chainId = client.chain?.id ?? await client.getChainId();
+		const sdk = new OnchainSDK(getNetworkType(chainId), { client });
+		await sdk.attach({ marketConfigurators: [] });
+		return sdk;
+	}
+	/** Every asset each feed is currently allowed on, keyed by lowercase feed. */
+	async #feedToAssets(store) {
+		const byFeed = /* @__PURE__ */ new Map();
+		for (const { token, priceFeeds } of await store.getTokenPriceFeedsMap()) for (const feed of priceFeeds) {
+			const key = lower(feed);
+			const assets = byFeed.get(key);
+			if (assets) assets.push(token.toLowerCase());
+			else byFeed.set(key, [token.toLowerCase()]);
+		}
+		return byFeed;
+	}
+};
+//#endregion
+export { InstanceOwnerTransactions };

package/dist/esm/permissionless/api/transactions/index.js

@@ -0,0 +1,3 @@
+import { InstanceOwnerTransactions } from "./InstanceOwnerTransactions.js";
+import "./types.js";
+export { InstanceOwnerTransactions };

package/dist/esm/permissionless/api/transactions/lp-price-feeds.js

@@ -0,0 +1,84 @@
+import { createRawTx } from "../../../onchain/utils/createRawTx.js";
+import { simulateMulticall } from "../../../onchain/utils/viem/simulateMulticall.js";
+import { priceFeedCompressorAbi } from "../../../abi/compressors/priceFeedCompressor.js";
+import "../../../onchain/index.js";
+import { decodeFunctionResult, encodeFunctionData, parseAbi } from "viem";
+//#region src/permissionless/api/transactions/lp-price-feeds.ts
+const LOWER_BOUND_FACTOR = 999n;
+const ilpPriceFeedAbi = parseAbi([
+	"function contractType() external view returns (bytes32)",
+	"function setLimiter(uint256 newLimiter) external",
+	"function getLPExchangeRate() public view returns (uint256 exchangeRate)",
+	"function lowerBound() external view returns (uint256)",
+	"function upperBound() external view returns (uint256)"
+]);
+function currentLowerBound(client, address) {
+	return client.readContract({
+		abi: ilpPriceFeedAbi,
+		address,
+		functionName: "lowerBound"
+	});
+}
+function getValue(client, address) {
+	return client.readContract({
+		abi: ilpPriceFeedAbi,
+		address,
+		functionName: "getLPExchangeRate"
+	});
+}
+function toLowerBound(value) {
+	return value * LOWER_BOUND_FACTOR / 1000n;
+}
+/**
+* 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.
+**/
+async function updateBounds(client, address) {
+	const value = await getValue(client, address);
+	const currentLowerBoundValue = await currentLowerBound(client, address);
+	const lowerBound = toLowerBound(value);
+	const deviationFromValue = Math.floor(Number(10000n * (value - currentLowerBoundValue) / currentLowerBoundValue)) / 1e4;
+	const deviationFromBound = Math.floor(Number(10000n * (lowerBound - currentLowerBoundValue) / currentLowerBoundValue)) / 1e4;
+	const txs = [];
+	if (deviationFromValue < 0 || Math.abs(deviationFromBound) > .005) txs.push(createRawTx(address, {
+		abi: ilpPriceFeedAbi,
+		functionName: "setLimiter",
+		args: [lowerBound]
+	}, `[${address}].setLimiter(${lowerBound}); // deviationFromValue: ${(100 * deviationFromValue).toFixed(2)}%`));
+	return txs;
+}
+/**
+* Of the whole feed tree behind `feeds`, the ones that are LP feeds: the
+* probe keeps whatever answers `getLPExchangeRate`.
+**/
+async function getFeedsToUpdate(client, pfCompressor, feeds) {
+	const updateableFeeds = /* @__PURE__ */ new Set();
+	const { data } = await client.call({
+		to: pfCompressor,
+		data: encodeFunctionData({
+			abi: priceFeedCompressorAbi,
+			functionName: "loadPriceFeedTree",
+			args: [feeds]
+		}),
+		gas: 200000000n
+	});
+	const trees = decodeFunctionResult({
+		abi: priceFeedCompressorAbi,
+		functionName: "loadPriceFeedTree",
+		data: data ?? "0x"
+	});
+	for (const tree of trees) updateableFeeds.add(tree.baseParams.addr.toLowerCase());
+	const candidates = Array.from(updateableFeeds);
+	const { results } = await simulateMulticall(client, {
+		contracts: candidates.map((feed) => ({
+			address: feed,
+			abi: ilpPriceFeedAbi,
+			functionName: "getLPExchangeRate"
+		})),
+		allowFailure: true
+	});
+	return candidates.filter((_, index) => results[index]?.status === "success");
+}
+//#endregion
+export { getFeedsToUpdate, updateBounds };

package/dist/esm/permissionless/api/transactions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/permissionless/api/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/permissionless/bindings/cross-chain-multisig.js

@@ -3,9 +3,9 @@ import { BaseContract } from "../../onchain/base/BaseContract.js";
 import "../../onchain/index.js";
 import { CROSS_CHAIN_MULTISIG } from "../utils/literals.js";
 import { normalizeSignature } from "../utils/signature.js";
-import { crossChainMultisigAbi } from "../../abi/310/crossChainMultisig.js";
 import "../deployment/addresses.js";
 import { InstanceManagerContract } from "./instance-manager.js";
+import { crossChainMultisigAbi } from "../../abi/310/crossChainMultisig.js";
 import { MarketConfiguratorFactoryContract } from "./market-configurator-factory.js";
 import { parseAbi, parseEventLogs, recoverTypedDataAddress, zeroAddress } from "viem";
 //#region src/permissionless/bindings/cross-chain-multisig.ts

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

@@ -1,10 +1,10 @@
-import { AddressProviderContract } from "./address-provider.js";
 import { BytecodeRepositoryContract } from "./bytecode-repository.js";
+import { priceFeedSetupParams } from "./pricefeeds/index.js";
+import { PriceFeedStoreContract } from "./price-feed-store.js";
+import { AddressProviderContract } from "./address-provider.js";
 import { TokenCompressorContract } from "./compressors/token-compressor.js";
 import { WithdrawalCompressorContract } from "./compressors/withdrawal-compressor.js";
 import "./compressors/index.js";
-import { priceFeedSetupParams } from "./pricefeeds/index.js";
-import { PriceFeedStoreContract } from "./price-feed-store.js";
 import { RoutingManagerContract } from "./router/routing-manager.js";
 import "./router/index.js";
 import { TreasurySplitterContract } from "./treasury-splitter.js";

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