@gearbox-protocol/sdk 18.2.0-next.11 → 18.2.0-next.13

package/dist/cjs/permissionless/api/oracles/score/index.js

@@ -2,7 +2,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_permissionless_api_oracles_score_formula = require("./formula.js");
 const require_permissionless_api_oracles_score_run = require("./run.js");
 require("./types.js");
-exports.BOUND_WEIGHT = require_permissionless_api_oracles_score_formula.BOUND_WEIGHT;
-exports.INDEPENDENCE_WEIGHT = require_permissionless_api_oracles_score_formula.INDEPENDENCE_WEIGHT;
+exports.REVERT_SCORE = require_permissionless_api_oracles_score_formula.REVERT_SCORE;
+exports.SCORE_MULTIPLIER = require_permissionless_api_oracles_score_formula.SCORE_MULTIPLIER;
+exports.factorOf = require_permissionless_api_oracles_score_formula.factorOf;
+exports.finalPrice = require_permissionless_api_oracles_score_formula.finalPrice;
 exports.runAssetScores = require_permissionless_api_oracles_score_run.runAssetScores;
-exports.scoreMarket = require_permissionless_api_oracles_score_formula.scoreMarket;
+exports.scoreOfFactor = require_permissionless_api_oracles_score_formula.scoreOfFactor;
+exports.worstOf = require_permissionless_api_oracles_score_formula.worstOf;

package/dist/cjs/permissionless/api/oracles/score/run.js

@@ -2,73 +2,156 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_permissionless_api_oracles_stress_classify = require("../stress/classify.js");
 const require_permissionless_api_oracles_stress_run = require("../stress/run.js");
 const require_permissionless_api_oracles_score_formula = require("./formula.js");
+let viem = require("viem");
 //#region src/permissionless/api/oracles/score/run.ts
+const ZERO_TYPE = "PRICE_FEED::ZERO";
+/** Groups simulated at once: one `eth_call` each, all against one node. */
+const CONCURRENCY = 6;
+const feedOf = (slot) => slot.priceFeed.toLowerCase();
 /**
-* How a source is told apart from another when two feeds are compared.
+* Every asset of one chain, scored by what each of its source groups can do
+* to the price its running markets hold for it.
 *
-* A named source by its group, since two Chainlink aggregators are one
-* provider failing together. An unnamed one by its contract, since nothing
-* says what else it fails with — so the same contract on both sides is
-* shared, and two different ones are not.
-*/
-function toScoreSource(source) {
-	return {
-		key: source.identified ? `group:${source.group}` : `contract:${source.target}`,
-		name: source.group,
-		identified: source.identified
-	};
-}
-/**
-* Every asset of one chain, scored by how its running markets price it.
-*
-* One read of every oracle's feed tree and one of the LP feeds' rate
-* contracts, both multicalls: the score is a reading of the trees and needs
-* no simulation.
+* One read of the oracles' feed trees, one of the LP feeds' rate contracts,
+* one of every market feed as it stands — then one `eth_call` per source
+* group, with the group's sources overridden to answer
+* {@link SCORE_MULTIPLIER} times what they answer now and every market feed
+* read under it.
 **/
 async function runAssetScores({ client, chainId, slots, compressor, logger }) {
 	const running = slots.filter((slot) => !slot.isShutdown);
 	const oracles = [...new Set(running.map((slot) => slot.priceOracle.toLowerCase()))];
-	const { nodes, unreadableOracles } = await require_permissionless_api_oracles_stress_run.readForest(client, compressor, oracles);
+	const { nodes, answers, unreadableOracles } = await require_permissionless_api_oracles_stress_run.readForest(client, compressor, oracles);
 	for (const oracle of unreadableOracles) logger?.warn(`price oracle ${oracle} of chain ${chainId} would not report its feed tree; the markets on it are not scored`);
-	const { targets } = await require_permissionless_api_oracles_stress_run.readRateTargets(client, [...nodes.values()].filter((node) => require_permissionless_api_oracles_stress_run.RATE_FEED_TYPE.test(node.contractType)).map((node) => node.address));
-	const { sources } = require_permissionless_api_oracles_stress_classify.classifySources(chainId, [...nodes.values()], targets, () => null);
-	const byTarget = new Map(sources.filter((source) => source.perturbable).map((source) => [source.target, toScoreSource(source)]));
-	const feedOf = (slot) => slot.priceFeed.toLowerCase();
-	const reach = require_permissionless_api_oracles_stress_classify.sourcesByFeed([...new Set(running.map(feedOf))], nodes, sources);
-	const sourcesOf = (feed) => [...reach.get(feed) ?? []].map((target) => byTarget.get(target)).filter((source) => source !== void 0);
-	const positions = /* @__PURE__ */ new Map();
+	const { targets, baselines: rateBaselines } = await require_permissionless_api_oracles_stress_run.readRateTargets(client, [...nodes.values()].filter((node) => require_permissionless_api_oracles_stress_run.RATE_FEED_TYPE.test(node.contractType)).map((node) => node.address));
+	const { sources, unresolved } = require_permissionless_api_oracles_stress_classify.classifySources(chainId, [...nodes.values()], targets, (target) => rateBaselines.get(target) ?? answers.get(target) ?? null);
+	for (const node of unresolved) logger?.warn(`feed ${node.address} of chain ${chainId} would not say what it reads its rate from; its protocol is not perturbed`);
+	const slotsByPosition = /* @__PURE__ */ new Map();
 	for (const slot of running) {
 		const key = `${slot.market.toLowerCase()}:${slot.token.toLowerCase()}`;
-		const position = positions.get(key) ?? {};
-		position[slot.reserve ? "reserve" : "main"] = slot;
-		positions.set(key, position);
+		const entry = slotsByPosition.get(key) ?? {};
+		entry[slot.reserve ? "reserve" : "main"] = slot;
+		slotsByPosition.set(key, entry);
 	}
-	const byAsset = /* @__PURE__ */ new Map();
-	for (const { main, reserve } of positions.values()) {
+	const positions = [];
+	for (const { main, reserve } of slotsByPosition.values()) {
 		if (!main || main.isUnderlying) continue;
+		const mainNode = nodes.get(feedOf(main));
+		if (!mainNode || mainNode.contractType === ZERO_TYPE) continue;
+		const notes = [];
+		let reserveFeed;
+		if (!reserve) notes.push("no reserve feed");
+		else if (nodes.get(feedOf(reserve))?.contractType === ZERO_TYPE) notes.push("reserve is a ZeroPriceFeed");
+		else {
+			reserveFeed = feedOf(reserve);
+			if (reserveFeed === feedOf(main)) notes.push("reserve is the main feed");
+		}
+		positions.push({
+			main,
+			reserve,
+			reserveFeed,
+			notes
+		});
+	}
+	const priced = [...new Set(positions.flatMap(({ main, reserveFeed }) => reserveFeed ? [feedOf(main), reserveFeed] : [feedOf(main)]))];
+	if (priced.length === 0) return [];
+	const underlyingOf = (slot) => slot.underlyingPriceFeed?.toLowerCase();
+	const roots = [.../* @__PURE__ */ new Set([...priced, ...positions.map(({ main }) => underlyingOf(main)).filter((feed) => feed !== void 0)])];
+	const updatedAt = BigInt(Math.floor(Date.now() / 1e3));
+	const drivable = (source) => source !== void 0 && source.perturbable && source.baseline !== null;
+	const fresh = sources.filter((source) => drivable(source) && source.kind === "feed");
+	const asIs = await require_permissionless_api_oracles_stress_run.readUnder(client, roots, [], 1, updatedAt);
+	const stale = roots.filter((root) => (asIs.get(root) ?? null) === null);
+	const freshened = stale.length > 0 ? await require_permissionless_api_oracles_stress_run.readUnder(client, stale, [], 1, updatedAt, fresh) : /* @__PURE__ */ new Map();
+	const base = new Map(roots.map((root) => [root, asIs.get(root) ?? freshened.get(root) ?? null]));
+	const asIsRoots = roots.filter((root) => (asIs.get(root) ?? null) !== null);
+	const freshRoots = stale.filter((root) => (freshened.get(root) ?? null) !== null);
+	/** Every root under a lie, each read the way its base was. */
+	const readLying = async (members) => {
+		const [plain, refreshed] = await Promise.all([asIsRoots.length > 0 ? require_permissionless_api_oracles_stress_run.readUnder(client, asIsRoots, members, 5, updatedAt) : /* @__PURE__ */ new Map(), freshRoots.length > 0 ? require_permissionless_api_oracles_stress_run.readUnder(client, freshRoots, members, 5, updatedAt, fresh) : /* @__PURE__ */ new Map()]);
+		return new Map([...plain, ...refreshed]);
+	};
+	for (const position of positions) if (position.reserveFeed && (base.get(position.reserveFeed) ?? null) === null) {
+		position.reserveFeed = void 0;
+		position.notes.push("reserve does not answer");
+	}
+	const reach = require_permissionless_api_oracles_stress_classify.sourcesByFeed(roots, nodes, sources);
+	const sourceByTarget = new Map(sources.map((source) => [source.target, source]));
+	const byGroup = /* @__PURE__ */ new Map();
+	for (const source of sources.filter(drivable)) byGroup.set(source.group, [...byGroup.get(source.group) ?? [], source]);
+	const reachedGroups = /* @__PURE__ */ new Set();
+	for (const root of priced) for (const target of reach.get(root) ?? []) {
+		const source = sourceByTarget.get(target);
+		if (drivable(source)) reachedGroups.add(source.group);
+	}
+	const stressed = /* @__PURE__ */ new Map();
+	const queue = [...reachedGroups];
+	for (let i = 0; i < queue.length; i += CONCURRENCY) await Promise.all(queue.slice(i, i + CONCURRENCY).map(async (group) => {
+		stressed.set(group, await readLying(byGroup.get(group) ?? []));
+	}));
+	const groupsOf = (feed) => {
+		const out = /* @__PURE__ */ new Map();
+		for (const target of feed ? reach.get(feed) ?? [] : []) {
+			const source = sourceByTarget.get(target);
+			if (drivable(source)) out.set(source.group, [...out.get(source.group) ?? [], source]);
+		}
+		return out;
+	};
+	const byAsset = /* @__PURE__ */ new Map();
+	for (const { main, reserve, reserveFeed, notes } of positions) {
+		const mainFeed = feedOf(main);
+		const before = require_permissionless_api_oracles_score_formula.finalPrice(base.get(mainFeed) ?? null, reserveFeed ? base.get(reserveFeed) ?? null : void 0);
+		if (before === null || before <= 0n) {
+			logger?.warn(`feed ${mainFeed} of chain ${chainId} does not answer; ${main.tokenSymbol ?? main.token} in ${main.marketName ?? main.market} is not scored`);
+			continue;
+		}
+		const onMain = groupsOf(mainFeed);
+		const onReserve = groupsOf(reserveFeed);
+		const impacts = [.../* @__PURE__ */ new Set([...onMain.keys(), ...onReserve.keys()])].map((group) => {
+			const under = stressed.get(group) ?? /* @__PURE__ */ new Map();
+			const after = require_permissionless_api_oracles_score_formula.finalPrice(under.get(mainFeed) ?? null, reserveFeed ? under.get(reserveFeed) ?? null : void 0);
+			const factor = require_permissionless_api_oracles_score_formula.factorOf(before, after);
+			const underlying = underlyingOf(main);
+			const debtBefore = underlying ? base.get(underlying) ?? null : null;
+			const debtFactor = debtBefore === null || debtBefore <= 0n || !underlying ? null : require_permissionless_api_oracles_score_formula.factorOf(debtBefore, under.get(underlying) ?? null);
+			const ratioFactor = factor === null || debtFactor === null || debtFactor === 0 ? null : factor / debtFactor;
+			const members = [...onMain.get(group) ?? [], ...onReserve.get(group) ?? []];
+			return {
+				group,
+				identified: members.every((source) => source.identified),
+				feeds: [...new Set(members.map((source) => source.description))],
+				reaches: onMain.has(group) ? onReserve.has(group) ? "both" : "main" : "reserve",
+				factor,
+				ratioFactor,
+				score: require_permissionless_api_oracles_score_formula.scoreOfFactor(factor)
+			};
+		});
+		const unverified = reserveFeed !== void 0 && impacts.some((impact) => !impact.identified && impact.reaches !== "both");
+		const side = (slot) => ({
+			feed: feedOf(slot),
+			name: slot.priceFeedName,
+			contractType: nodes.get(feedOf(slot))?.contractType ?? "",
+			sources: [...groupsOf(feedOf(slot)).keys()]
+		});
 		const asset = main.token.toLowerCase();
 		const entry = byAsset.get(asset) ?? {
 			symbol: main.tokenSymbol,
 			markets: []
 		};
 		byAsset.set(asset, entry);
-		const mainNode = nodes.get(feedOf(main));
-		if (!mainNode) continue;
-		if (mainNode.contractType === "PRICE_FEED::ZERO") continue;
-		const side = (slot) => ({
-			feed: {
-				feed: feedOf(slot),
-				name: slot.priceFeedName,
-				contractType: nodes.get(feedOf(slot))?.contractType ?? ""
-			},
-			sources: sourcesOf(feedOf(slot))
-		});
-		entry.markets.push(require_permissionless_api_oracles_score_formula.scoreMarket({
+		entry.markets.push({
 			market: main.market,
 			marketName: main.marketName,
 			marketConfigurator: main.marketConfigurator,
-			curatorName: main.curatorName
-		}, side(main), reserve ? side(reserve) : null));
+			curatorName: main.curatorName,
+			main: side(main),
+			reserve: reserve ? side(reserve) : null,
+			hasReserve: reserveFeed !== void 0,
+			price: Number((0, viem.formatUnits)(before, 8)),
+			unverified,
+			notes,
+			...require_permissionless_api_oracles_score_formula.worstOf(impacts)
+		});
 	}
 	return [...byAsset].map(([asset, { symbol, markets }]) => {
 		const sorted = markets.sort((a, b) => a.score - b.score);

package/dist/cjs/permissionless/api/oracles/stress/index.js

@@ -14,6 +14,7 @@ exports.perturb = require_permissionless_api_oracles_stress_override.perturb;
 exports.rateStub = require_permissionless_api_oracles_stress_override.rateStub;
 exports.readForest = require_permissionless_api_oracles_stress_run.readForest;
 exports.readRateTargets = require_permissionless_api_oracles_stress_run.readRateTargets;
+exports.readUnder = require_permissionless_api_oracles_stress_run.readUnder;
 exports.roundDataStub = require_permissionless_api_oracles_stress_override.roundDataStub;
 exports.runStressTest = require_permissionless_api_oracles_stress_run.runStressTest;
 exports.scoreGroup = require_permissionless_api_oracles_stress_score.scoreGroup;

package/dist/cjs/permissionless/api/oracles/stress/run.js

@@ -161,8 +161,10 @@ async function readRateTargets(client, feeds) {
 * scenario rather than a round trip per feed. A feed that reverts comes back
 * `null`, which is an outcome and not an error.
 */
-async function readUnder(client, feeds, sources, multiplier, updatedAt) {
-	const overrides = require_permissionless_api_oracles_stress_override.groupOverride(sources, multiplier, updatedAt);
+async function readUnder(client, feeds, sources, multiplier, updatedAt, freshen = []) {
+	const driven = require_permissionless_api_oracles_stress_override.groupOverride(sources, multiplier, updatedAt);
+	const taken = new Set(driven.map((override) => override.address.toLowerCase()));
+	const overrides = [...require_permissionless_api_oracles_stress_override.groupOverride(freshen, 1, updatedAt).filter((override) => !taken.has(override.address.toLowerCase())), ...driven];
 	const results = await client.multicall({
 		contracts: feeds.map((address) => ({
 			address,
@@ -429,4 +431,5 @@ exports.DEFAULT_SCENARIOS = DEFAULT_SCENARIOS;
 exports.RATE_FEED_TYPE = RATE_FEED_TYPE;
 exports.readForest = readForest;
 exports.readRateTargets = readRateTargets;
+exports.readUnder = readUnder;
 exports.runStressTest = runStressTest;

package/dist/cjs/permissionless/bindings/bytecode-repository.js

@@ -33,6 +33,14 @@ var BytecodeRepositoryContract = class BytecodeRepositoryContract extends requir
 	async getLatestVersion(type_) {
 		return await this.contract.read.getLatestVersion([(0, viem.stringToHex)(type_, { size: 32 })]);
 	}
+	/**
+	* Returns the latest allowed patch version of the contract type within given minor version
+	* @throws if no bytecode of this contract type and minor version is allowed
+	*/
+	async getLatestPatchVersion(type_, minorVersion) {
+		const version = await this.contract.read.getLatestPatchVersion([(0, viem.stringToHex)(type_, { size: 32 }), BigInt(minorVersion)]);
+		return Number(version);
+	}
 	async getAllowedBytecodeHash(type_, version) {
 		return await this.contract.read.getAllowedBytecodeHash([(0, viem.stringToHex)(type_, { size: 32 }), BigInt(version)]);
 	}

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

@@ -6,8 +6,8 @@ require("../../../onchain/index.js");
 const require_permissionless_bindings_bytecode_repository = require("../bytecode-repository.js");
 require("../../deployment/addresses.js");
 const require_permissionless_bindings_treasury_splitter = require("../treasury-splitter.js");
-const require_abi_governance_governor = require("../../../abi/governance/governor.js");
 const require_permissionless_bindings_market_configurator = require("../market-configurator.js");
+const require_abi_governance_governor = require("../../../abi/governance/governor.js");
 const require_permissionless_bindings_governance_batches_chain = require("./batches-chain.js");
 let viem = require("viem");
 let viem_utils = require("viem/utils");

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

@@ -10,10 +10,11 @@ const require_permissionless_bindings_router_routing_manager = require("./router
 require("./router/index.js");
 const require_permissionless_bindings_treasury_splitter = require("./treasury-splitter.js");
 const require_permissionless_bindings_instance_manager = require("./instance-manager.js");
-const require_permissionless_bindings_market_configurator_factory = require("./market-configurator-factory.js");
-const require_permissionless_bindings_cross_chain_multisig = require("./cross-chain-multisig.js");
 const require_permissionless_bindings_types = require("./types.js");
 const require_permissionless_bindings_market_configurator = require("./market-configurator.js");
+const require_permissionless_bindings_kill_switch_proxy = require("./kill-switch-proxy.js");
+const require_permissionless_bindings_market_configurator_factory = require("./market-configurator-factory.js");
+const require_permissionless_bindings_cross_chain_multisig = require("./cross-chain-multisig.js");
 const require_permissionless_bindings_governance_governor = require("./governance/governor.js");
 const require_permissionless_bindings_governance_timelock = require("./governance/timelock.js");
 require("./governance/index.js");
@@ -23,6 +24,9 @@ exports.BytecodeRepositoryContract = require_permissionless_bindings_bytecode_re
 exports.CrossChainMultisigContract = require_permissionless_bindings_cross_chain_multisig.CrossChainMultisigContract;
 exports.GovernorContract = require_permissionless_bindings_governance_governor.GovernorContract;
 exports.InstanceManagerContract = require_permissionless_bindings_instance_manager.InstanceManagerContract;
+exports.KILL_SWITCH_PROXY_MINOR_VERSION = require_permissionless_bindings_kill_switch_proxy.KILL_SWITCH_PROXY_MINOR_VERSION;
+exports.KillSwitchProxyContract = require_permissionless_bindings_kill_switch_proxy.KillSwitchProxyContract;
+exports.KillSwitchProxyNotAllowedError = require_permissionless_bindings_kill_switch_proxy.KillSwitchProxyNotAllowedError;
 exports.MarketConfiguratorContract = require_permissionless_bindings_market_configurator.MarketConfiguratorContract;
 exports.MarketConfiguratorFactoryContract = require_permissionless_bindings_market_configurator_factory.MarketConfiguratorFactoryContract;
 exports.PriceFeedStoreContract = require_permissionless_bindings_price_feed_store.PriceFeedStoreContract;
@@ -31,4 +35,5 @@ exports.TimeLockContract = require_permissionless_bindings_governance_timelock.T
 exports.TokenCompressorContract = require_permissionless_bindings_compressors_token_compressor.TokenCompressorContract;
 exports.TreasurySplitterContract = require_permissionless_bindings_treasury_splitter.TreasurySplitterContract;
 exports.WithdrawalCompressorContract = require_permissionless_bindings_compressors_withdrawal_compressor.WithdrawalCompressorContract;
+exports.killSwitchProxySalt = require_permissionless_bindings_kill_switch_proxy.killSwitchProxySalt;
 exports.priceFeedSetupParams = require_permissionless_bindings_pricefeeds_index.priceFeedSetupParams;

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

@@ -0,0 +1,188 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_json = require("../../onchain/utils/json.js");
+const require_onchain_base_BaseContract = require("../../onchain/base/BaseContract.js");
+require("../../onchain/index.js");
+const require_permissionless_utils_literals = require("../utils/literals.js");
+const require_abi_310_iKillSwitchProxy = require("../../abi/310/iKillSwitchProxy.js");
+const require_permissionless_bindings_market_configurator = require("./market-configurator.js");
+let viem = require("viem");
+//#region src/permissionless/bindings/kill-switch-proxy.ts
+const abi = require_abi_310_iKillSwitchProxy.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 (0, viem.keccak256)((0, viem.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 viem.BaseError {
+	name = "KillSwitchProxyNotAllowedError";
+	bytecodeRepository;
+	constructor(bytecodeRepository) {
+		super(`${require_permissionless_utils_literals.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 require_onchain_base_BaseContract.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 ((0, viem.isAddressEqual)(owner, viem.zeroAddress) || (0, viem.isAddressEqual)(caller, viem.zeroAddress)) throw new Error(`${require_permissionless_utils_literals.KILL_SWITCH_PROXY} owner and caller must be non-zero`);
+		if ((0, viem.isAddressEqual)(owner, caller)) throw new Error(`${require_permissionless_utils_literals.KILL_SWITCH_PROXY} owner must differ from caller ${caller}, provide another kill switch owner`);
+		const [constructorAbi] = abi;
+		return (0, viem.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: require_permissionless_utils_literals.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: require_permissionless_utils_literals.KILL_SWITCH_PROXY,
+				version: BigInt(version),
+				encodedParams,
+				salt
+			})
+		};
+	}
+	static async #getVersion(bcr) {
+		try {
+			return await bcr.getLatestPatchVersion(require_permissionless_utils_literals.KILL_SWITCH_PROXY, 310);
+		} catch (e) {
+			const revert = e instanceof viem.BaseError ? e.walk((err) => err instanceof viem.ContractFunctionRevertedError) : null;
+			if (revert instanceof viem.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 require_permissionless_bindings_market_configurator.MarketConfiguratorContract(target, this.client).parseFunctionData(data);
+				if (decoded.functionName.startsWith("Unknown function")) return {
+					target,
+					data
+				};
+				return {
+					target,
+					functionName: decoded.functionName,
+					data: require_onchain_utils_json.json_stringify(decoded.args)
+				};
+			}
+			default: return super.parseFunctionParams(params);
+		}
+	}
+};
+//#endregion
+exports.KILL_SWITCH_PROXY_MINOR_VERSION = KILL_SWITCH_PROXY_MINOR_VERSION;
+exports.KillSwitchProxyContract = KillSwitchProxyContract;
+exports.KillSwitchProxyNotAllowedError = KillSwitchProxyNotAllowedError;
+exports.killSwitchProxySalt = killSwitchProxySalt;

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

@@ -1,8 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_base_BaseContract = require("../../onchain/base/BaseContract.js");
 require("../../onchain/index.js");
+const require_permissionless_utils_literals = require("../utils/literals.js");
+const require_permissionless_bindings_bytecode_repository = require("./bytecode-repository.js");
+require("../deployment/addresses.js");
+const require_abi_310_iMarketConfiguratorFactory = require("../../abi/310/iMarketConfiguratorFactory.js");
+const require_permissionless_bindings_kill_switch_proxy = require("./kill-switch-proxy.js");
 //#region src/permissionless/bindings/market-configurator-factory.ts
-const abi = require("../../abi/310/iMarketConfiguratorFactory.js").iMarketConfiguratorFactoryAbi;
+const abi = require_abi_310_iMarketConfiguratorFactory.iMarketConfiguratorFactoryAbi;
 var MarketConfiguratorFactoryContract = class extends require_onchain_base_BaseContract.BaseContract {
 	constructor(addr, client) {
 		super({ client }, {
@@ -22,6 +27,39 @@ var MarketConfiguratorFactoryContract = class extends require_onchain_base_BaseC
 			]
 		});
 	}
+	/**
+	* 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 require_permissionless_bindings_bytecode_repository.BytecodeRepositoryContract("0x1cE2B1BE96a082b1b1539F80d5D8f82Ec06a0f9A", this.client);
+		const proxy = await require_permissionless_bindings_kill_switch_proxy.KillSwitchProxyContract.prepareDeploy(bcr, {
+			deployer: admin,
+			owner: killSwitchOwner ?? admin,
+			caller: emergencyAdmin,
+			salt: require_permissionless_bindings_kill_switch_proxy.killSwitchProxySalt(args.curatorName)
+		});
+		if (proxy.isKilled) throw new Error(`${require_permissionless_utils_literals.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()];
 	}