@gearbox-protocol/sdk 18.3.0 → 18.4.0

package/dist/esm/permissionless/bindings/governance/governor.js

@@ -5,8 +5,8 @@ import "../../../onchain/index.js";
 import { BytecodeRepositoryContract } from "../bytecode-repository.js";
 import "../../deployment/addresses.js";
 import { TreasurySplitterContract } from "../treasury-splitter.js";
-import { governorAbi } from "../../../abi/governance/governor.js";
 import { MarketConfiguratorContract } from "../market-configurator.js";
+import { governorAbi } from "../../../abi/governance/governor.js";
 import { BatchesChainContract } from "./batches-chain.js";
 import { encodeAbiParameters, formatEther, keccak256, toBytes } from "viem";
 import { formatAbiItem } from "viem/utils";

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

@@ -1,6 +1,7 @@
 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";
@@ -8,12 +9,12 @@ import { RoutingManagerContract } from "./router/routing-manager.js";
 import "./router/index.js";
 import { TreasurySplitterContract } from "./treasury-splitter.js";
 import { InstanceManagerContract } from "./instance-manager.js";
-import { AddressProviderContract } from "./address-provider.js";
-import { MarketConfiguratorFactoryContract } from "./market-configurator-factory.js";
-import { CrossChainMultisigContract } from "./cross-chain-multisig.js";
 import { AccessMode } from "./types.js";
 import { MarketConfiguratorContract } from "./market-configurator.js";
+import { KILL_SWITCH_PROXY_MINOR_VERSION, KillSwitchProxyContract, KillSwitchProxyNotAllowedError, killSwitchProxySalt } from "./kill-switch-proxy.js";
+import { MarketConfiguratorFactoryContract } from "./market-configurator-factory.js";
+import { CrossChainMultisigContract } from "./cross-chain-multisig.js";
 import { GovernorContract } from "./governance/governor.js";
 import { TimeLockContract } from "./governance/timelock.js";
 import "./governance/index.js";
-export { AccessMode, AddressProviderContract, BytecodeRepositoryContract, CrossChainMultisigContract, GovernorContract, InstanceManagerContract, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PriceFeedStoreContract, RoutingManagerContract, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, WithdrawalCompressorContract, priceFeedSetupParams };
+export { AccessMode, AddressProviderContract, BytecodeRepositoryContract, CrossChainMultisigContract, GovernorContract, InstanceManagerContract, KILL_SWITCH_PROXY_MINOR_VERSION, KillSwitchProxyContract, KillSwitchProxyNotAllowedError, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PriceFeedStoreContract, RoutingManagerContract, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, WithdrawalCompressorContract, killSwitchProxySalt, priceFeedSetupParams };

package/dist/esm/permissionless/bindings/kill-switch-proxy.js

@@ -0,0 +1,184 @@
+import { json_stringify } from "../../onchain/utils/json.js";
+import { BaseContract } from "../../onchain/base/BaseContract.js";
+import "../../onchain/index.js";
+import { KILL_SWITCH_PROXY } from "../utils/literals.js";
+import { iKillSwitchProxyAbi } from "../../abi/310/iKillSwitchProxy.js";
+import { MarketConfiguratorContract } from "./market-configurator.js";
+import { BaseError, ContractFunctionRevertedError, encodeAbiParameters, isAddressEqual, keccak256, toHex, zeroAddress } from "viem";
+//#region src/permissionless/bindings/kill-switch-proxy.ts
+const abi = iKillSwitchProxyAbi;
+/**
+* Minor version of kill switch proxy, the latest allowed patch of it is deployed
+*/
+const KILL_SWITCH_PROXY_MINOR_VERSION = 310;
+/**
+* Salt of kill switch proxy deployed together with market configurator,
+* makes each curator's market configurator get its own proxy
+*/
+function killSwitchProxySalt(curatorName) {
+	return keccak256(toHex(curatorName));
+}
+/**
+* Thrown when bytecode repository has no allowed kill switch proxy bytecode,
+* so its address can't be computed and it can't be deployed
+*/
+var KillSwitchProxyNotAllowedError = class extends BaseError {
+	name = "KillSwitchProxyNotAllowedError";
+	bytecodeRepository;
+	constructor(bytecodeRepository) {
+		super(`${KILL_SWITCH_PROXY} v310 is not allowed in bytecode repository ${bytecodeRepository}.`, { metaMessages: ["Its bytecode must be uploaded, audited and allowed before it can be deployed."] });
+		this.bytecodeRepository = bytecodeRepository;
+	}
+};
+/**
+* Kill switch proxy forwards calls of its `caller` via `proxyCall` until `owner` kills it.
+* It is used as market configurator's emergency admin, so that emergency powers
+* can be revoked instantly without going through the timelock.
+*/
+var KillSwitchProxyContract = class KillSwitchProxyContract extends BaseContract {
+	constructor(addr, client) {
+		super({ client }, {
+			abi,
+			addr,
+			name: "KillSwitchProxy"
+		});
+	}
+	/**
+	* Encodes `constructor(address _owner, address _caller)` params
+	* @throws if any address is zero or owner equals caller (constructor reverts in that case)
+	*/
+	static encodeConstructorParams(args) {
+		const { owner, caller } = args;
+		if (isAddressEqual(owner, zeroAddress) || isAddressEqual(caller, zeroAddress)) throw new Error(`${KILL_SWITCH_PROXY} owner and caller must be non-zero`);
+		if (isAddressEqual(owner, caller)) throw new Error(`${KILL_SWITCH_PROXY} owner must differ from caller ${caller}, provide another kill switch owner`);
+		const [constructorAbi] = abi;
+		return encodeAbiParameters(constructorAbi.inputs, [owner, caller]);
+	}
+	/**
+	* Returns whether some patch of kill switch proxy v3.10 is allowed in bytecode repository
+	*/
+	static async isAvailable(bcr) {
+		try {
+			await KillSwitchProxyContract.#getVersion(bcr);
+			return true;
+		} catch (e) {
+			if (e instanceof KillSwitchProxyNotAllowedError) return false;
+			throw e;
+		}
+	}
+	/**
+	* Computes address of kill switch proxy and prepares its deployment via bytecode repository
+	* @param bcr - bytecode repository
+	* @param args.deployer - address that will send deployment transaction, it is mixed into the salt
+	* @param args.owner - address that can kill the proxy
+	* @param args.caller - address that can call through the proxy
+	* @param args.salt - deployment salt
+	* @throws {KillSwitchProxyNotAllowedError} if kill switch proxy is not allowed in bytecode repository
+	*/
+	static async prepareDeploy(bcr, args) {
+		const { deployer, owner, caller, salt } = args;
+		const encodedParams = KillSwitchProxyContract.encodeConstructorParams({
+			owner,
+			caller
+		});
+		const version = await KillSwitchProxyContract.#getVersion(bcr);
+		const [isAlreadyDeployed, address] = await bcr.isAlreadyDeployedAddress({
+			contractType: KILL_SWITCH_PROXY,
+			version,
+			encodedParams,
+			salt,
+			owner: deployer
+		});
+		return {
+			address,
+			version,
+			encodedParams,
+			salt,
+			isAlreadyDeployed,
+			isKilled: isAlreadyDeployed ? await new KillSwitchProxyContract(address, bcr.client).isKilled() : false,
+			tx: bcr.deployTx({
+				contractType: KILL_SWITCH_PROXY,
+				version: BigInt(version),
+				encodedParams,
+				salt
+			})
+		};
+	}
+	static async #getVersion(bcr) {
+		try {
+			return await bcr.getLatestPatchVersion(KILL_SWITCH_PROXY, 310);
+		} catch (e) {
+			const revert = e instanceof BaseError ? e.walk((err) => err instanceof ContractFunctionRevertedError) : null;
+			if (revert instanceof ContractFunctionRevertedError && revert.data?.errorName === "VersionNotFoundException") throw new KillSwitchProxyNotAllowedError(bcr.address);
+			throw e;
+		}
+	}
+	async isKilled() {
+		return await this.contract.read.isKilled();
+	}
+	async state() {
+		const [caller, owner, isKilled] = await this.client.multicall({
+			allowFailure: false,
+			contracts: [
+				{
+					address: this.address,
+					abi,
+					functionName: "caller"
+				},
+				{
+					address: this.address,
+					abi,
+					functionName: "owner"
+				},
+				{
+					address: this.address,
+					abi,
+					functionName: "isKilled"
+				}
+			],
+			batchSize: 0
+		});
+		return {
+			caller,
+			owner,
+			isKilled
+		};
+	}
+	/**
+	* Wraps transaction into `proxyCall`, must be sent by proxy's caller
+	*/
+	proxyCallTx(tx) {
+		return this.createRawTx({
+			functionName: "proxyCall",
+			args: [tx.to, tx.callData],
+			description: tx.description ? `KillSwitchProxy.proxyCall(${tx.description})` : void 0
+		});
+	}
+	/**
+	* Permanently disables `proxyCall`, must be sent by proxy's owner
+	*/
+	killTx() {
+		return this.createRawTx({ functionName: "kill" });
+	}
+	parseFunctionParams(params) {
+		const { functionName, args } = params;
+		switch (functionName) {
+			case "proxyCall": {
+				const [target, data] = args;
+				const decoded = new MarketConfiguratorContract(target, this.client).parseFunctionData(data);
+				if (decoded.functionName.startsWith("Unknown function")) return {
+					target,
+					data
+				};
+				return {
+					target,
+					functionName: decoded.functionName,
+					data: json_stringify(decoded.args)
+				};
+			}
+			default: return super.parseFunctionParams(params);
+		}
+	}
+};
+//#endregion
+export { KILL_SWITCH_PROXY_MINOR_VERSION, KillSwitchProxyContract, KillSwitchProxyNotAllowedError, killSwitchProxySalt };

package/dist/esm/permissionless/bindings/market-configurator-factory.js

@@ -1,6 +1,10 @@
 import { BaseContract } from "../../onchain/base/BaseContract.js";
 import "../../onchain/index.js";
+import { KILL_SWITCH_PROXY } from "../utils/literals.js";
+import { BytecodeRepositoryContract } from "./bytecode-repository.js";
+import "../deployment/addresses.js";
 import { iMarketConfiguratorFactoryAbi } from "../../abi/310/iMarketConfiguratorFactory.js";
+import { KillSwitchProxyContract, killSwitchProxySalt } from "./kill-switch-proxy.js";
 //#region src/permissionless/bindings/market-configurator-factory.ts
 const abi = iMarketConfiguratorFactoryAbi;
 var MarketConfiguratorFactoryContract = class extends BaseContract {
@@ -22,6 +26,39 @@ var MarketConfiguratorFactoryContract = class extends BaseContract {
 			]
 		});
 	}
+	/**
+	* Builds transactions that deploy market configurator with kill switch proxy as its emergency admin:
+	* 1. kill switch proxy deployment via bytecode repository (skipped if already deployed)
+	* 2. market configurator creation with proxy as emergency admin
+	*
+	* Transactions must be sent in this order by `admin`, e.g. as one Safe batch.
+	* When `deployGovernor` is true, proxy also becomes governor's veto admin.
+	*
+	* @param args.admin - address that sends transactions, becomes market configurator admin
+	* @param args.emergencyAdmin - address that executes emergency actions through the proxy
+	* @param args.killSwitchOwner - address that can kill the proxy, defaults to `admin`
+	* @throws {KillSwitchProxyNotAllowedError} if kill switch proxy is not allowed in bytecode repository,
+	* use {@link createMarketConfiguratorTx} to deploy market configurator without it
+	*/
+	async createMarketConfiguratorWithKillSwitchTxs(args) {
+		const { admin, emergencyAdmin, killSwitchOwner, ...rest } = args;
+		const bcr = new BytecodeRepositoryContract("0x1cE2B1BE96a082b1b1539F80d5D8f82Ec06a0f9A", this.client);
+		const proxy = await KillSwitchProxyContract.prepareDeploy(bcr, {
+			deployer: admin,
+			owner: killSwitchOwner ?? admin,
+			caller: emergencyAdmin,
+			salt: killSwitchProxySalt(args.curatorName)
+		});
+		if (proxy.isKilled) throw new Error(`${KILL_SWITCH_PROXY} ${proxy.address} is already deployed and killed`);
+		return {
+			killSwitchProxy: proxy.address,
+			isKillSwitchProxyDeployed: proxy.isAlreadyDeployed,
+			txs: [...proxy.isAlreadyDeployed ? [] : [proxy.tx], this.createMarketConfiguratorTx({
+				...rest,
+				emergencyAdmin: proxy.address
+			})]
+		};
+	}
 	async getMarketConfigurators() {
 		return [...await this.contract.read.getMarketConfigurators()];
 	}

package/dist/esm/permissionless/bindings/market-configurator.js

@@ -1,8 +1,11 @@
 import { iMarketConfiguratorV310Abi } from "../../abi/310/generated.js";
 import { json_stringify } from "../../onchain/utils/json.js";
+import { createRawTx } from "../../onchain/utils/createRawTx.js";
 import { BaseContract } from "../../onchain/base/BaseContract.js";
 import "../../onchain/index.js";
+import { KILL_SWITCH_PROXY } from "../utils/literals.js";
 import { AddressProviderContract } from "./address-provider.js";
+import { iKillSwitchProxyAbi } from "../../abi/310/iKillSwitchProxy.js";
 import { creditFacadeParamsAbi, creditManagerParamsAbi } from "../../abi/310/configure/creditSuiteParams.js";
 import { parseIrmDeployParams } from "../plugins/irm/constructor-params-abi.js";
 import { parseLossPolicyDeployParams } from "../plugins/loss-policies/constructor-params-abi.js";
@@ -15,7 +18,7 @@ import { LossPolicyFactory } from "./factory/loss-policy-factory.js";
 import { PoolFactory } from "./factory/pool-factory.js";
 import { PriceOracleFactory } from "./factory/price-oracle-factory.js";
 import { RateKeeperFactory } from "./factory/rate-keeper-factory.js";
-import { decodeAbiParameters, encodeAbiParameters, encodeFunctionData, erc20Abi, erc4626Abi, hexToString, keccak256, parseAbi, stringToHex, toBytes } from "viem";
+import { decodeAbiParameters, encodeAbiParameters, encodeFunctionData, erc20Abi, erc4626Abi, hexToString, isAddressEqual, keccak256, parseAbi, stringToHex, toBytes } from "viem";
 //#region src/permissionless/bindings/market-configurator.ts
 const PERIPHERY_DOMAINS = ["ZAPPER", "DEGEN_NFT"];
 const abi = iMarketConfiguratorV310Abi;
@@ -395,6 +398,83 @@ var MarketConfiguratorContract = class extends BaseContract {
 			return;
 		}
 	}
+	/**
+	* Returns emergency admin of the market configurator.
+	* If it is a `KILL_SWITCH_PROXY`, emergency transactions must be sent by proxy's caller via `proxyCall`,
+	* otherwise directly by emergency admin itself
+	* @param emergencyAdmin - emergency admin address, read from the market configurator if not provided
+	*/
+	async getEmergencyAdmin(emergencyAdmin) {
+		const address = emergencyAdmin ?? await this.contract.read.emergencyAdmin();
+		const [contractType, caller, owner, isKilled] = await this.client.multicall({
+			allowFailure: true,
+			contracts: [
+				{
+					address,
+					abi: iKillSwitchProxyAbi,
+					functionName: "contractType"
+				},
+				{
+					address,
+					abi: iKillSwitchProxyAbi,
+					functionName: "caller"
+				},
+				{
+					address,
+					abi: iKillSwitchProxyAbi,
+					functionName: "owner"
+				},
+				{
+					address,
+					abi: iKillSwitchProxyAbi,
+					functionName: "isKilled"
+				}
+			],
+			batchSize: 0
+		});
+		let isKillSwitch = false;
+		if (contractType.status === "success") try {
+			isKillSwitch = hexToString(contractType.result, { size: 32 }) === KILL_SWITCH_PROXY;
+		} catch {}
+		if (!isKillSwitch) return {
+			type: "direct",
+			address,
+			executor: address
+		};
+		if (caller.status !== "success" || owner.status !== "success" || isKilled.status !== "success") throw new Error(`failed to read state of ${KILL_SWITCH_PROXY} emergency admin ${address}`);
+		return {
+			type: "killSwitch",
+			address,
+			caller: caller.result,
+			owner: owner.result,
+			isKilled: isKilled.result,
+			executor: caller.result
+		};
+	}
+	/**
+	* Routes emergency transaction to the market configurator through its emergency admin:
+	* returns transaction as is for direct emergency admin, or wraps it into `proxyCall` of kill switch proxy
+	* @param tx - emergency transaction to the market configurator, e.g. built by `emergencyConfigurePool`
+	* @param emergencyAdmin - result of {@link getEmergencyAdmin}
+	* @throws if transaction is not addressed to this market configurator or kill switch proxy is killed
+	*/
+	wrapEmergencyTx(tx, emergencyAdmin) {
+		if (!isAddressEqual(tx.to, this.address)) throw new Error(`emergency tx target ${tx.to} is not market configurator ${this.address}`);
+		if (emergencyAdmin.type === "direct") return tx;
+		if (emergencyAdmin.isKilled) throw new Error(`${KILL_SWITCH_PROXY} ${emergencyAdmin.address} of market configurator ${this.address} is killed`);
+		return createRawTx(emergencyAdmin.address, {
+			abi: iKillSwitchProxyAbi,
+			functionName: "proxyCall",
+			args: [this.address, tx.callData]
+		}, tx.description ? `KillSwitchProxy.proxyCall(${tx.description})` : void 0);
+	}
+	/**
+	* Reads emergency admin and routes emergency transaction through it, see {@link wrapEmergencyTx}
+	* @param tx - emergency transaction to the market configurator, e.g. built by `emergencyConfigurePool`
+	*/
+	async emergencyTx(tx) {
+		return this.wrapEmergencyTx(tx, await this.getEmergencyAdmin());
+	}
 	grantRole(role, address) {
 		return this.createRawTx({
 			functionName: "grantRole",
@@ -608,9 +688,53 @@ var MarketConfiguratorContract = class extends BaseContract {
 					role: hexToString(role, { size: 32 })
 				};
 			}
+			case "emergencyConfigurePool":
+			case "emergencyConfigurePriceOracle":
+			case "emergencyConfigureLossPolicy":
+			case "emergencyConfigureRateKeeper":
+			case "emergencyConfigureInterestRateModel": {
+				const [pool, calldata] = args;
+				const decoded = this.#decodeEmergencyConfig(functionName, calldata);
+				return decoded ? {
+					pool,
+					data: json_stringify(decoded)
+				} : {
+					pool,
+					calldata
+				};
+			}
+			case "emergencyConfigureCreditSuite": {
+				const [creditManager, calldata] = args;
+				const decoded = this.#decodeEmergencyConfig(functionName, calldata);
+				return decoded ? {
+					creditManager,
+					data: json_stringify(decoded)
+				} : {
+					creditManager,
+					calldata
+				};
+			}
 			default: return super.parseFunctionParams(params);
 		}
 	}
+	/**
+	* Emergency actions share selectors with regular configuration actions only partially
+	* (e.g., `pause`, `forbidToken`, `setPriceFeed`), so decoding is best-effort
+	*/
+	#decodeEmergencyConfig(functionName, calldata) {
+		const factory = {
+			emergencyConfigurePool: this.poolFactory,
+			emergencyConfigureCreditSuite: this.creditFactory,
+			emergencyConfigurePriceOracle: this.priceOracleFactory,
+			emergencyConfigureLossPolicy: this.lossPolicyFactory,
+			emergencyConfigureRateKeeper: this.rateKeeperFactory
+		}[functionName];
+		try {
+			return factory?.decodeConfig(calldata) ?? null;
+		} catch {
+			return null;
+		}
+	}
 	emergencyConfigurePool(pool, calldata) {
 		return this.createRawTx({
 			functionName: "emergencyConfigurePool",
@@ -635,6 +759,24 @@ var MarketConfiguratorContract = class extends BaseContract {
 			args: [pool, calldata]
 		});
 	}
+	/**
+	* Note: current interest rate model factory forbids all emergency configuration calls
+	*/
+	emergencyConfigureInterestRateModel(pool, calldata) {
+		return this.createRawTx({
+			functionName: "emergencyConfigureInterestRateModel",
+			args: [pool, calldata]
+		});
+	}
+	/**
+	* Note: current rate keeper factory forbids all emergency configuration calls
+	*/
+	emergencyConfigureRateKeeper(pool, calldata) {
+		return this.createRawTx({
+			functionName: "emergencyConfigureRateKeeper",
+			args: [pool, calldata]
+		});
+	}
 };
 //#endregion
 export { MarketConfiguratorContract };

package/dist/esm/permissionless/index.js

@@ -2,7 +2,7 @@ import { PermissionlessAnalytics } from "./api/analytics/PermissionlessAnalytics
 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 { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, KILL_SWITCH_PROXY, 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 { priceFeedSetupParams } from "./bindings/pricefeeds/index.js";
@@ -10,7 +10,14 @@ 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 { AddressProviderContract } from "./bindings/address-provider.js";
+import { getFeedDecimals, getLatestPrices, getPrices } from "./utils/price-update/get-prices.js";
+import { classifySources, sourcesByFeed } from "./api/oracles/stress/classify.js";
+import { UNBOUNDED_DOWN, UNBOUNDED_UP, groupOverride, perturb, rateStub, roundDataStub } from "./api/oracles/stress/override.js";
+import { scoreGroup, slotHarm, verdictOf } from "./api/oracles/stress/score.js";
+import { DEFAULT_SCENARIOS, RATE_FEED_TYPE, readFeedTrees, readForest, readRateTargets, readUnder, runStressTest } from "./api/oracles/stress/run.js";
+import { SCORE_MULTIPLIER, factorOf, finalPrice, scoreOfFactor, worstOf } from "./api/oracles/score/formula.js";
+import { runAssetScores, runFeedPairScore } from "./api/oracles/score/run.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./api/oracles/PermissionlessOracles.js";
 import { TokenCompressorContract } from "./bindings/compressors/token-compressor.js";
 import { WithdrawalCompressorContract } from "./bindings/compressors/withdrawal-compressor.js";
@@ -22,14 +29,14 @@ import { getUpdatablePriceFeeds } from "./utils/price-update/get-updatable-feeds
 import { InstanceOwnerTransactions } from "./api/transactions/InstanceOwnerTransactions.js";
 import { GearboxPermissionless } from "./api/GearboxPermissionless.js";
 import "./api/index.js";
-import { AddressProviderContract } from "./bindings/address-provider.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";
 import { convertPercent, deepJsonParse, formatBytecodeSize, formatBytecodeVersion, shortenHash, significantTrunc } from "./utils/format.js";
 import { createCallData } from "./core/raw-tx.js";
 import { AccessMode } from "./bindings/types.js";
 import { MarketConfiguratorContract } from "./bindings/market-configurator.js";
+import { KILL_SWITCH_PROXY_MINOR_VERSION, KillSwitchProxyContract, KillSwitchProxyNotAllowedError, killSwitchProxySalt } from "./bindings/kill-switch-proxy.js";
+import { MarketConfiguratorFactoryContract } from "./bindings/market-configurator-factory.js";
+import { CrossChainMultisigContract } from "./bindings/cross-chain-multisig.js";
 import { GovernorContract } from "./bindings/governance/governor.js";
 import { TimeLockContract } from "./bindings/governance/timelock.js";
 import "./bindings/index.js";
@@ -41,4 +48,4 @@ import { getBlockNumberByTimestamp } from "./utils/block-utils.js";
 import { convertQueueBatchToExecuteTx } from "./utils/governance/timelock-txs.js";
 import { getPriceUpdateTx } from "./utils/price-update/get-price-update-tx.js";
 import "./utils/index.js";
-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, PermissionlessAnalytics, 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 };
+export { AccessMode, AddressProviderContract, Addresses, ArchiveTransport, BYTECODE_REPOSITORY, BytecodeRepositoryContract, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainsNamespace, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, DEFAULT_SCENARIOS, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GovernorContract, INSTANCE_MANAGER, InstanceManagerContract, InstanceOwnerTransactions, KILL_SWITCH_PROXY, KILL_SWITCH_PROXY_MINOR_VERSION, KillSwitchProxyContract, KillSwitchProxyNotAllowedError, 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, PermissionlessAnalytics, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, PriceFeedStoreContract, RATE_FEED_TYPE, RoutingManagerContract, SCORE_MULTIPLIER, TOKEN_COMPRESSOR, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, UNBOUNDED_DOWN, UNBOUNDED_UP, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, classifySources, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, factorOf, finalPrice, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getFeedDecimals, getLatestPrices, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, groupOverride, handleSalt, killSwitchProxySalt, normalizeSignature, perturb, priceFeedSalt, priceFeedSetupParams, rateStub, readFeedTrees, readForest, readRateTargets, readUnder, roundDataStub, runAssetScores, runFeedPairScore, runStressTest, scoreGroup, scoreOfFactor, shortenHash, significantTrunc, slotHarm, sourcesByFeed, verdictOf, worstOf };

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

@@ -1,7 +1,7 @@
-import { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, MARKET_CONFIGURATOR_FACTORY, PRICE_FEED_STORE, TOKEN_COMPRESSOR } from "./literals.js";
+import { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, KILL_SWITCH_PROXY, 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 { getFeedDecimals, getLatestPrices, 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";
@@ -11,4 +11,4 @@ import { convertQueueBatchToExecuteTx } from "./governance/timelock-txs.js";
 import "./governance/index.js";
 import { getPriceUpdateTx } from "./price-update/get-price-update-tx.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 };
+export { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, KILL_SWITCH_PROXY, 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, getFeedDecimals, getLatestPrices, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, shortenHash, significantTrunc };

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

@@ -6,5 +6,6 @@ const TOKEN_COMPRESSOR = "GLOBAL::TOKEN_COMPRESSOR";
 const CROSS_CHAIN_MULTISIG = "CROSS_CHAIN_MULTISIG";
 const PRICE_FEED_STORE = "PRICE_FEED_STORE";
 const MARKET_CONFIGURATOR_FACTORY = "MARKET_CONFIGURATOR_FACTORY";
+const KILL_SWITCH_PROXY = "KILL_SWITCH_PROXY";
 //#endregion
-export { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, MARKET_CONFIGURATOR_FACTORY, PRICE_FEED_STORE, TOKEN_COMPRESSOR };
+export { BYTECODE_REPOSITORY, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, INSTANCE_MANAGER, KILL_SWITCH_PROXY, MARKET_CONFIGURATOR_FACTORY, PRICE_FEED_STORE, TOKEN_COMPRESSOR };

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

@@ -31,6 +31,16 @@ const latestRoundDataAbi = [{
 	stateMutability: "view",
 	type: "function"
 }];
+const decimalsAbi = [{
+	inputs: [],
+	name: "decimals",
+	outputs: [{
+		name: "",
+		type: "uint8"
+	}],
+	stateMutability: "view",
+	type: "function"
+}];
 function getLatestRoundDataCall(priceFeed) {
 	return {
 		address: priceFeed,
@@ -39,6 +49,58 @@ function getLatestRoundDataCall(priceFeed) {
 		args: []
 	};
 }
+/**
+* The scale each feed's answer is in, in one multicall.
+*
+* Part of the Chainlink interface every feed in a Gearbox tree implements,
+* and the only way to read an answer that is not an oracle's own: a feed an
+* oracle holds reports 8 decimals by construction, while the feeds beneath a
+* composite are whatever was deployed — an ETH/USD aggregator at 8 and a
+* rate leg at 18 sit under the same parent.
+*
+* `null` is a feed that would not answer, which a caller should treat as
+* unknown rather than defaulting it to 8.
+*/
+async function getFeedDecimals({ client, priceFeeds }) {
+	if (priceFeeds.length === 0) return {};
+	const results = await client.multicall({
+		contracts: priceFeeds.map((priceFeed) => ({
+			address: priceFeed,
+			abi: decimalsAbi,
+			functionName: "decimals",
+			args: []
+		})),
+		allowFailure: true
+	});
+	return Object.fromEntries(priceFeeds.map((priceFeed, index) => {
+		const result = results[index];
+		return [priceFeed, result?.status === "success" ? Number(result.result) : null];
+	}));
+}
+/**
+* What the feeds report as they stand, in one multicall.
+*
+* What {@link getPrices} does without the part that makes it expensive: no
+* `OnchainSDK` to attach and no update transactions to assemble, which is the
+* whole cost of that call and is wasted on a feed that answers already. A feed
+* that needs a fresh answer before it will be read comes back `null` here, so
+* a caller that must price those falls back to {@link getPrices} for them and
+* pays once for the few rather than once for all.
+*
+* `null` is also a feed whose read reverted for any other reason, which is not
+* a zero.
+*/
+async function getLatestPrices({ client, priceFeeds }) {
+	if (priceFeeds.length === 0) return {};
+	const results = await client.multicall({
+		contracts: priceFeeds.map(getLatestRoundDataCall),
+		allowFailure: true
+	});
+	return Object.fromEntries(priceFeeds.map((priceFeed, index) => {
+		const result = results[index];
+		return [priceFeed, result?.status === "success" ? result.result[1] : null];
+	}));
+}
 async function getPricesChunk({ client, priceFeeds, sdk }) {
 	const updateCall = priceFeeds.map((priceFeed) => getLatestRoundDataCall(priceFeed));
 	const multicallCalls = (await sdk.priceFeeds.generateExternalPriceFeedsUpdateTxs(priceFeeds)).txs.map((tx) => ({
@@ -82,4 +144,4 @@ async function getPrices({ client, priceFeeds, chunkSize = 10, gasLimit }) {
 	}), {});
 }
 //#endregion
-export { getPrices };
+export { getFeedDecimals, getLatestPrices, getPrices };

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

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