@morpho-dev/router 0.7.0 → 0.7.1

package/dist/index.browser.mjs

@@ -253,107 +253,14 @@ const Morpho = [
 //#region src/core/Callback.ts
 var Callback_exports = /* @__PURE__ */ __exportAll({
 	Type: () => Type$1,
-	decode: () => decode$2,
-	decodeBuyERC20: () => decodeBuyERC20,
-	decodeBuyVaultV1Callback: () => decodeBuyVaultV1Callback,
-	decodeSellERC20Callback: () => decodeSellERC20Callback,
-	encode: () => encode$2,
-	encodeBuyERC20: () => encodeBuyERC20,
-	encodeBuyVaultV1Callback: () => encodeBuyVaultV1Callback,
-	encodeSellERC20Callback: () => encodeSellERC20Callback,
 	isEmptyCallback: () => isEmptyCallback
 });
 let Type$1 = /* @__PURE__ */ function(Type) {
 	Type["BuyWithEmptyCallback"] = "buy_with_empty_callback";
-	Type["BuyERC20"] = "buy_erc20";
-	Type["BuyVaultV1Callback"] = "buy_vault_v1_callback";
-	Type["SellERC20Callback"] = "sell_erc20_callback";
+	Type["SellWithEmptyCallback"] = "sell_with_empty_callback";
 	return Type;
 }({});
 const isEmptyCallback = (offer) => offer.callback.data === "0x";
-function decode$2(type, data) {
-	switch (type) {
-		case Type$1.BuyERC20: return decodeBuyERC20(data);
-		case Type$1.BuyVaultV1Callback: return decodeBuyVaultV1Callback(data);
-		case Type$1.SellERC20Callback: return decodeSellERC20Callback(data);
-		default: throw new Error("Invalid callback type");
-	}
-}
-function encode$2(type, data) {
-	switch (type) {
-		case Type$1.BuyERC20:
-			if (!("tokens" in data)) throw new Error("Invalid callback data");
-			return encodeBuyERC20(data);
-		case Type$1.BuyVaultV1Callback:
-			if (!("vaults" in data)) throw new Error("Invalid callback data");
-			return encodeBuyVaultV1Callback(data);
-		case Type$1.SellERC20Callback:
-			if (!("collaterals" in data)) throw new Error("Invalid callback data");
-			return encodeSellERC20Callback(data);
-		default: throw new Error("Invalid callback type");
-	}
-}
-/**
-* Decodes BuyERC20 callback data into positions.
-* @param data - The ABI-encoded callback data containing token addresses and amounts.
-* @returns Array of positions with contract address and amount.
-* @throws If data is empty, malformed, or arrays have mismatched lengths.
-*/
-function decodeBuyERC20(data) {
-	if (!data || data === "0x") throw new Error("Empty callback data");
-	let tokens;
-	let amounts;
-	try {
-		[tokens, amounts] = decodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], data);
-	} catch (_) {
-		throw new Error("Invalid BuyERC20 callback data");
-	}
-	if (tokens.length !== amounts.length) throw new Error("Mismatched array lengths");
-	return tokens.map((token, index) => ({
-		contract: token,
-		amount: amounts[index]
-	}));
-}
-/**
-* Encodes BuyERC20 callback parameters into ABI-encoded data.
-* @param parameters - The tokens and amounts to encode.
-* @returns ABI-encoded hex string.
-*/
-function encodeBuyERC20(parameters) {
-	return encodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], [parameters.tokens, parameters.amounts]);
-}
-function decodeBuyVaultV1Callback(data) {
-	if (!data || data === "0x") throw new Error("Empty callback data");
-	try {
-		const [vaults, amounts] = decodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], data);
-		if (vaults.length !== amounts.length) throw new Error("Mismatched array lengths");
-		return vaults.map((v, i) => ({
-			contract: v,
-			amount: amounts[i]
-		}));
-	} catch (_) {
-		throw new Error("Invalid BuyVaultV1Callback callback data");
-	}
-}
-function decodeSellERC20Callback(data) {
-	if (!data || data === "0x") throw new Error("Empty callback data");
-	try {
-		const [collaterals, amounts] = decodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], data);
-		if (collaterals.length !== amounts.length) throw new Error("Mismatched array lengths");
-		return collaterals.map((c, i) => ({
-			contract: c,
-			amount: amounts[i]
-		}));
-	} catch (_) {
-		throw new Error("Invalid SellERC20Callback callback data");
-	}
-}
-function encodeBuyVaultV1Callback(parameters) {
-	return encodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], [parameters.vaults, parameters.amounts]);
-}
-function encodeSellERC20Callback(parameters) {
-	return encodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], [parameters.collaterals, parameters.amounts]);
-}
 
 //#endregion
 //#region src/utils/BigMath.ts
@@ -1109,11 +1016,9 @@ var Liquidity_exports = /* @__PURE__ */ __exportAll({
 	calculateMaxDebt: () => calculateMaxDebt,
 	generateAllowancePoolId: () => generateAllowancePoolId,
 	generateBalancePoolId: () => generateBalancePoolId,
-	generateBuyVaultCallbackPoolId: () => generateBuyVaultCallbackPoolId,
 	generateDebtPoolId: () => generateDebtPoolId,
 	generateMarketLiquidityPoolId: () => generateMarketLiquidityPoolId,
 	generateObligationCollateralPoolId: () => generateObligationCollateralPoolId,
-	generateSellERC20CallbackPoolId: () => generateSellERC20CallbackPoolId,
 	generateUserVaultPositionPoolId: () => generateUserVaultPositionPoolId,
 	generateVaultPositionPoolId: () => generateVaultPositionPoolId
 });
@@ -1142,14 +1047,6 @@ function generateAllowancePoolId(parameters) {
 	return `${user}-${chainId.toString()}-${token}-allowance`.toLowerCase();
 }
 /**
-* Generate pool ID for sell ERC20 callback pools.
-* Each offer has its own callback pool to prevent liquidity conflicts.
-*/
-function generateSellERC20CallbackPoolId(parameters) {
-	const { user, chainId, obligationId, token, offerHash } = parameters;
-	return `${user}-${chainId.toString()}-${obligationId}-${token}-${offerHash}-sell_erc20_callback`.toLowerCase();
-}
-/**
 * Generate pool ID for obligation collateral pools.
 * Obligation collateral pools represent collateral already deposited in the obligation.
 * These pools are shared across all offers with the same obligation.
@@ -1159,13 +1056,6 @@ function generateObligationCollateralPoolId(parameters) {
 	return `${user}-${chainId.toString()}-${obligationId}-${token}-obligation-collateral`.toLowerCase();
 }
 /**
-* Generate pool ID for buy vault callback pools.
-*/
-function generateBuyVaultCallbackPoolId(parameters) {
-	const { user, chainId, vault, offerHash } = parameters;
-	return `${user}-${chainId.toString()}-${vault}-${offerHash}-${Type$1.BuyVaultV1Callback}`.toLowerCase();
-}
-/**
 * Generate pool ID for debt pools.
 */
 function generateDebtPoolId(parameters) {
@@ -1545,6 +1435,7 @@ var Offer_exports = /* @__PURE__ */ __exportAll({
 	obligationId: () => obligationId,
 	random: () => random$1,
 	serialize: () => serialize,
+	takeEvent: () => takeEvent,
 	toSnakeCase: () => toSnakeCase,
 	types: () => types
 });
@@ -1663,7 +1554,7 @@ function random$1(config) {
 	const chain = config?.chains ? config.chains[int(config.chains.length)] : chains$1.ethereum;
 	const loanToken = config?.loanTokens ? config.loanTokens[int(config.loanTokens.length)] : address();
 	const collateralCandidates = config?.collateralTokens ? config.collateralTokens.filter((a) => a !== loanToken) : [address()];
-	const collateralAsset = collateralCandidates[int(collateralCandidates.length)];
+	collateralCandidates[int(collateralCandidates.length)];
 	const maturityOption = weightedChoice([["end_of_month", 1], ["end_of_next_month", 1]]);
 	const maturity = config?.maturity ?? from$11(maturityOption);
 	const lltv = from$13(weightedChoice([
@@ -1690,21 +1581,10 @@ function random$1(config) {
 	const unit = BigInt(10) ** BigInt(loanTokenDecimals);
 	const amountBase = BigInt(100 + int(999901));
 	const assetsScaled = config?.assets ?? amountBase * unit;
-	const callbackBySide = (() => {
-		if (buy) return {
-			address: zeroAddress,
-			data: "0x"
-		};
-		const sellCallbackAddress = "0x3333333333333333333333333333333333333333";
-		const amount = assetsScaled * 1000000000000000000000n;
-		return {
-			address: sellCallbackAddress,
-			data: encodeSellERC20Callback({
-				collaterals: [collateralAsset],
-				amounts: [amount]
-			})
-		};
-	})();
+	const emptyCallback = {
+		address: zeroAddress,
+		data: "0x"
+	};
 	return from$9({
 		maker: config?.maker ?? address(),
 		assets: assetsScaled,
@@ -1723,7 +1603,7 @@ function random$1(config) {
 			...random$3(),
 			lltv
 		})).sort((a, b) => a.asset.localeCompare(b.asset)),
-		callback: config?.callback ?? callbackBySide
+		callback: config?.callback ?? emptyCallback
 	});
 }
 const weightedChoice = (pairs) => {
@@ -2013,6 +1893,94 @@ function decode$1(data) {
 	});
 }
 /**
+* ABI for the Take event emitted by the Morpho V2 contract.
+*/
+const takeEvent = {
+	type: "event",
+	name: "Take",
+	inputs: [
+		{
+			name: "caller",
+			type: "address",
+			indexed: false,
+			internalType: "address"
+		},
+		{
+			name: "id",
+			type: "bytes32",
+			indexed: true,
+			internalType: "bytes32"
+		},
+		{
+			name: "maker",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "taker",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "offerIsBuy",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "buyerAssets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "sellerAssets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "obligationUnits",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "obligationShares",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "buyerIsLender",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "sellerIsBorrower",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "group",
+			type: "bytes32",
+			indexed: false,
+			internalType: "bytes32"
+		},
+		{
+			name: "consumed",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		}
+	],
+	anonymous: false
+};
+/**
 * ABI for the Consume event emitted by the Obligation contract.
 */
 const consumedEvent = {
@@ -2867,8 +2835,8 @@ const offerExample = {
 		price: "2750000000000000000",
 		group: "0x000000000000000000000000000000000000000000000000000000000008b8f4",
 		session: "0x0000000000000000000000000000000000000000000000000000000000000000",
-		callback: "0x1111111111111111111111111111111111111111",
-		callback_data: "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000"
+		callback: "0x0000000000000000000000000000000000000000",
+		callback_data: "0x"
 	},
 	offer_hash: "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427",
 	obligation_id: "0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc",
@@ -2920,25 +2888,10 @@ const validateOfferExample = {
 		lltv: "860000000000000000"
 	}],
 	callback: {
-		address: "0x1111111111111111111111111111111111111111",
-		data: "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000"
+		address: "0x0000000000000000000000000000000000000000",
+		data: "0x"
 	}
 };
-const callbackTypesRequestExample = { callbacks: [{
-	chain_id: 1,
-	addresses: [
-		"0x1111111111111111111111111111111111111111",
-		"0x3333333333333333333333333333333333333333",
-		"0x9999999999999999999999999999999999999999"
-	]
-}] };
-const callbackTypesResponseExample = [{
-	chain_id: 1,
-	sell_erc20_callback: ["0x1111111111111111111111111111111111111111"],
-	buy_erc20: ["0x5555555555555555555555555555555555555555"],
-	buy_vault_v1_callback: ["0x3333333333333333333333333333333333333333"],
-	not_supported: ["0x9999999999999999999999999999999999999999"]
-}];
 const routerStatusExample = {
 	status: "live",
 	initialized: true,
@@ -3007,55 +2960,6 @@ __decorate([ApiProperty({
 	type: "string",
 	example: validateOfferExample.callback.data
 })], ValidateCallbackRequest.prototype, "data", void 0);
-var CallbackTypesChainRequest = class {};
-__decorate([ApiProperty({
-	type: "number",
-	example: callbackTypesRequestExample.callbacks[0].chain_id
-})], CallbackTypesChainRequest.prototype, "chain_id", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	example: callbackTypesRequestExample.callbacks[0].addresses
-})], CallbackTypesChainRequest.prototype, "addresses", void 0);
-var CallbackTypesRequest = class {};
-__decorate([ApiProperty({
-	type: () => [CallbackTypesChainRequest],
-	example: callbackTypesRequestExample.callbacks
-})], CallbackTypesRequest.prototype, "callbacks", void 0);
-var CallbackTypesChainResponse = class {};
-__decorate([ApiProperty({
-	type: "number",
-	example: callbackTypesResponseExample[0].chain_id
-})], CallbackTypesChainResponse.prototype, "chain_id", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].buy_vault_v1_callback
-})], CallbackTypesChainResponse.prototype, "buy_vault_v1_callback", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].sell_erc20_callback
-})], CallbackTypesChainResponse.prototype, "sell_erc20_callback", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].buy_erc20
-})], CallbackTypesChainResponse.prototype, "buy_erc20", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	example: callbackTypesResponseExample[0].not_supported
-})], CallbackTypesChainResponse.prototype, "not_supported", void 0);
-var CallbackTypesSuccessResponse = class extends SuccessResponse {};
-__decorate([ApiProperty({
-	type: "string",
-	nullable: true,
-	example: "maturity:1:1730415600:end_of_next_month"
-})], CallbackTypesSuccessResponse.prototype, "cursor", void 0);
-__decorate([ApiProperty({
-	type: () => [CallbackTypesChainResponse],
-	description: "Callback types grouped by chain.",
-	example: callbackTypesResponseExample
-})], CallbackTypesSuccessResponse.prototype, "data", void 0);
 var AskResponse = class {};
 __decorate([ApiProperty({
 	type: "string",
@@ -3573,7 +3477,7 @@ __decorate([
 		methods: ["post"],
 		path: "/v1/validate",
 		summary: "Validate offers",
-		description: "Validates offers against router validation rules. Returns unsigned payload + root on success, or issues only on validation failure."
+		description: "Validates offers against router validation rules. Only empty callbacks (zero address, 0x data) are accepted. Returns unsigned payload + root on success, or issues only on validation failure."
 	}),
 	ApiBody({ type: ValidateOffersRequest }),
 	ApiResponse({
@@ -3592,28 +3496,6 @@ ValidateController = __decorate([ApiTags("Make"), ApiResponse({
 	description: "Bad Request",
 	type: BadRequestResponse
 })], ValidateController);
-let CallbacksController = class CallbacksController {
-	async resolveCallbackTypes() {}
-};
-__decorate([
-	ApiOperation({
-		methods: ["post"],
-		path: "/v1/callbacks",
-		summary: "Resolve callback types",
-		description: "Returns callback types for callback addresses grouped by chain."
-	}),
-	ApiBody({ type: CallbackTypesRequest }),
-	ApiResponse({
-		status: 200,
-		description: "Success",
-		type: CallbackTypesSuccessResponse
-	})
-], CallbacksController.prototype, "resolveCallbackTypes", null);
-CallbacksController = __decorate([ApiTags("Make"), ApiResponse({
-	status: 400,
-	description: "Bad Request",
-	type: BadRequestResponse
-})], CallbacksController);
 let OffersController = class OffersController {
 	async getOffers() {}
 };
@@ -3763,12 +3645,6 @@ const configRulesMaturityExample = {
 	name: "end_of_next_month",
 	timestamp: 1730415600
 };
-const configRulesCallbackExample = {
-	type: "callback",
-	chain_id: 1,
-	address: "0x1111111111111111111111111111111111111111",
-	callback_type: "sell_erc20_callback"
-};
 const configRulesLoanTokenExample = {
 	type: "loan_token",
 	chain_id: 1,
@@ -3782,7 +3658,6 @@ const configRulesOracleExample = {
 const configRulesChecksumExample = "f1d2d2f924e986ac86fdf7b36c94bcdf";
 const configRulesPayloadExample = [
 	configRulesMaturityExample,
-	configRulesCallbackExample,
 	configRulesLoanTokenExample,
 	configRulesOracleExample
 ];
@@ -3847,14 +3722,9 @@ __decorate([ApiProperty({
 })], ConfigRulesRuleResponse.prototype, "timestamp", void 0);
 __decorate([ApiProperty({
 	type: "string",
-	example: configRulesCallbackExample.address,
+	example: configRulesLoanTokenExample.address,
 	required: false
 })], ConfigRulesRuleResponse.prototype, "address", void 0);
-__decorate([ApiProperty({
-	type: "string",
-	example: configRulesCallbackExample.callback_type,
-	required: false
-})], ConfigRulesRuleResponse.prototype, "callback_type", void 0);
 var ConfigRulesSuccessResponse = class {};
 __decorate([ApiProperty({ type: () => ConfigRulesMeta })], ConfigRulesSuccessResponse.prototype, "meta", void 0);
 __decorate([ApiProperty({
@@ -3915,7 +3785,7 @@ __decorate([
 		methods: ["get"],
 		path: "/v1/config/rules",
 		summary: "Get config rules",
-		description: "Returns configured rules for supported chains."
+		description: "Returns configured rules (maturities, loan tokens, oracles) for supported chains."
 	}),
 	ApiQuery({
 		name: "cursor",
@@ -4094,8 +3964,7 @@ const OpenApi = async () => {
 			ObligationsController,
 			HealthController,
 			UsersController,
-			ValidateController,
-			CallbacksController
+			ValidateController
 		],
 		document: {
 			openapi: "3.1.0",
@@ -4352,16 +4221,6 @@ const GetBookParams = z$1.object({
 	})
 });
 const ValidateOffersBody = z$1.object({ offers: z$1.array(z$1.unknown()).min(1, { message: "'offers' must contain at least 1 offer" }) }).strict();
-const CallbackTypesBody = z$1.object({ callbacks: z$1.array(z$1.object({
-	chain_id: z$1.number().int().positive().meta({
-		description: "Chain id.",
-		example: 1
-	}),
-	addresses: z$1.array(z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Callback address must be a valid 20-byte address" }).transform((val) => val.toLowerCase())).meta({
-		description: "Callback contract addresses.",
-		example: ["0x1111111111111111111111111111111111111111", "0x3333333333333333333333333333333333333333"]
-	})
-}).strict()) }).strict();
 const GetUserPositionsParams = z$1.object({
 	...PaginationQueryParams.shape,
 	user_address: z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "User address must be a valid 20-byte address" }).transform((val) => val.toLowerCase()).meta({
@@ -4380,7 +4239,6 @@ const schemas = {
 	get_obligation: GetObligationParams,
 	get_book: GetBookParams,
 	validate_offers: ValidateOffersBody,
-	callback_types: CallbackTypesBody,
 	get_user_positions: GetUserPositionsParams
 };
 function parse(action, query) {
@@ -4395,7 +4253,6 @@ function safeParse(action, query, error) {
 var Schema_exports = /* @__PURE__ */ __exportAll({
 	BookResponse: () => BookResponse_exports,
 	BooksController: () => BooksController,
-	CallbacksController: () => CallbacksController,
 	ChainHealth: () => ChainHealth,
 	ChainsHealthResponse: () => ChainsHealthResponse,
 	CollectorHealth: () => CollectorHealth,
@@ -4674,23 +4531,11 @@ function createHttpClient(config) {
 			issues: []
 		};
 	};
-	const getCallbackTypes = async (requestPayload) => {
-		const response = await request("/v1/callbacks", {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify(requestPayload)
-		});
-		const json = await response.json();
-		if (!response.ok) throw new Error(`Gatekeeper callbacks request failed: ${extractErrorMessage(json) ?? response.statusText}`);
-		if (!("data" in json) || !Array.isArray(json.data)) throw new Error("Gatekeeper callbacks response is invalid.");
-		return json.data;
-	};
 	return {
 		baseUrl,
 		validate,
 		getConfigRules,
-		isAllowed,
-		getCallbackTypes
+		isAllowed
 	};
 }
 function mergeHeaders(base, extra) {
@@ -4814,36 +4659,6 @@ function create(parameters) {
 
 //#endregion
 //#region src/gatekeeper/GateConfig.ts
-/**
-* Returns the callback configuration for a given chain and callback type, if it exists.
-*
-* @param chain - Chain name for which to read the validation configuration
-* @param type - Callback type to retrieve
-* @returns The matching callback configuration or undefined if not configured
-*/
-function getCallback(chain, type) {
-	return configs[chain].callbacks?.find((c) => c.type === type);
-}
-/**
-* Attempts to infer the configured callback type from a callback address on a chain.
-* Skips the empty callback type as it does not carry addresses.
-*
-* @param chain - Chain name for which to infer the callback type
-* @param address - Callback contract address
-* @returns The callback type when found, otherwise undefined
-*/
-function getCallbackType(chain, address) {
-	return configs[chain].callbacks?.find((c) => c.type !== Type$1.BuyWithEmptyCallback && c.addresses.includes(address?.toLowerCase()))?.type;
-}
-/**
-* Returns the list of allowed non-empty callback addresses for a chain.
-*
-* @param chain - Chain name
-* @returns Array of allowed callback addresses (lowercased). Empty when none configured
-*/
-const getCallbackAddresses = (chain) => {
-	return configs[chain].callbacks?.filter((c) => c.type !== Type$1.BuyWithEmptyCallback).flatMap((c) => c.addresses) ?? [];
-};
 const assets = {
 	[ChainId.ETHEREUM.toString()]: [
 		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
@@ -4915,63 +4730,19 @@ const oracles = {
 };
 const configs = {
 	ethereum: {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0x1897A8997241C1cD4bD0698647e4EB7213535c24"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
-			},
-			{ type: Type$1.BuyWithEmptyCallback }
-		],
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
 		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
 	},
 	base: {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0xFf62A7c278C62eD665133147129245053Bbf5918"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
-			},
-			{ type: Type$1.BuyWithEmptyCallback }
-		],
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
 		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
 	},
 	"ethereum-virtual-testnet": {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0x1897A8997241C1cD4bD0698647e4EB7213535c24"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
-			},
-			{ type: Type$1.BuyWithEmptyCallback }
-		],
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
 		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
 	},
 	anvil: {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0x1897A8997241C1cD4bD0698647e4EB7213535c24"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
-			},
-			{ type: Type$1.BuyWithEmptyCallback }
-		],
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
 		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
 	}
 };
@@ -4991,109 +4762,13 @@ var Rules_exports = /* @__PURE__ */ __exportAll({
 /**
 * set of rules to validate offers.
 *
-* @param parameters - Validity parameters with chain and client
+* @param _parameters - Validity parameters with chain and client
 * @returns Array of validation rules to evaluate against offers
 */
-function validity(parameters) {
-	const { client } = parameters;
-	const sellErc20CallbackInvalid = single("sell_erc20_callback_invalid", "Validates that sell offers have valid ERC20 callback data matching offer collaterals", (offer) => {
-		const callbackType = getCallbackType(client.chain.name, offer.callback.address);
-		if (callbackType !== Type$1.SellERC20Callback) return;
-		const decoded = decode$2(callbackType, offer.callback.data);
-		if (decoded.length === 0) return { message: "Callback data cannot be decoded or is empty." };
-		if (callbackType === Type$1.SellERC20Callback) {
-			const offerCollaterals = new Set(offer.collaterals.map((c) => c.asset.toLowerCase()));
-			if (decoded.length !== offer.collaterals.length) return { message: `Sell callback collateral length mismatch. Expected ${offer.collaterals.length}, got ${decoded.length}.` };
-			for (const { contract } of decoded) if (!offerCollaterals.has(contract.toLowerCase())) return { message: "Sell callback collateral is not part of offer collaterals." };
-		}
-	});
-	const buyCallbackVaultInvalid = batch("buy_offers_callback_vault_invalid", "Validates that buy offers have valid vault callbacks registered in allowed factories with matching assets", async (offers) => {
-		const validationIssues = /* @__PURE__ */ new Map();
-		const offersByVaultAddress = /* @__PURE__ */ new Map();
-		for (let i = 0; i < offers.length; i++) {
-			const offer = offers[i];
-			if (getCallbackType(client.chain.name, offer.callback.address) !== Type$1.BuyVaultV1Callback) continue;
-			try {
-				const callbackVaults = decodeBuyVaultV1Callback(offer.callback.data);
-				for (const { contract } of callbackVaults) {
-					const normalizedVaultAddress = contract.toLowerCase();
-					if (!offersByVaultAddress.has(normalizedVaultAddress)) offersByVaultAddress.set(normalizedVaultAddress, []);
-					offersByVaultAddress.get(normalizedVaultAddress).push({
-						index: i,
-						offer
-					});
-				}
-			} catch (_) {}
-		}
-		const uniqueVaultAddresses = Array.from(offersByVaultAddress.keys());
-		if (uniqueVaultAddresses.length === 0) return validationIssues;
-		const allowedFactories = getCallback(client.chain.name, Type$1.BuyVaultV1Callback)?.vaultFactories.map((f) => f.toLowerCase());
-		if (!allowedFactories) return validationIssues;
-		const multicallContracts = [];
-		for (const vaultAddress of uniqueVaultAddresses) {
-			multicallContracts.push({
-				address: vaultAddress,
-				abi: ERC4626,
-				functionName: "asset"
-			});
-			for (const factoryAddress of allowedFactories) multicallContracts.push({
-				address: factoryAddress,
-				abi: MetaMorphoFactory,
-				functionName: "isMetaMorpho",
-				args: [vaultAddress]
-			});
-		}
-		const multicallResults = await multicall(client, {
-			contracts: multicallContracts,
-			allowFailure: true
-		});
-		const vaultAssetByAddress = /* @__PURE__ */ new Map();
-		const registeredVaults = /* @__PURE__ */ new Set();
-		const numberOfFactories = allowedFactories.length;
-		let resultIndex = 0;
-		for (const vaultAddress of uniqueVaultAddresses) {
-			const assetCallResult = multicallResults[resultIndex++];
-			const assetAddress = assetCallResult.status === "success" ? assetCallResult.result : null;
-			vaultAssetByAddress.set(vaultAddress, assetAddress);
-			let isRegisteredInFactory = false;
-			for (let factoryIndex = 0; factoryIndex < numberOfFactories; factoryIndex++) {
-				const factoryCallResult = multicallResults[resultIndex++];
-				if (factoryCallResult.status === "success" && factoryCallResult.result === true) isRegisteredInFactory = true;
-			}
-			if (isRegisteredInFactory) registeredVaults.add(vaultAddress);
-		}
-		const uniqueOffers = /* @__PURE__ */ new Map();
-		for (const offersArray of offersByVaultAddress.values()) for (const { index, offer } of offersArray) uniqueOffers.set(index, offer);
-		for (const [index, offer] of uniqueOffers) try {
-			const callbackVaults = decodeBuyVaultV1Callback(offer.callback.data);
-			const vaultsWithIssues = [];
-			for (const { contract } of callbackVaults) {
-				const normalizedVaultAddress = contract.toLowerCase();
-				const assetAddress = vaultAssetByAddress.get(normalizedVaultAddress);
-				const isRegistered = registeredVaults.has(normalizedVaultAddress);
-				const failureReasons = [];
-				if (assetAddress === null) failureReasons.push("asset call failed");
-				else if (assetAddress && assetAddress.toLowerCase() !== offer.loanToken.toLowerCase()) failureReasons.push("asset mismatch");
-				if (!isRegistered) failureReasons.push("not registered in factory");
-				if (failureReasons.length > 0) vaultsWithIssues.push({
-					vaultAddress: contract,
-					failureReasons: failureReasons.join(", ")
-				});
-			}
-			if (vaultsWithIssues.length > 0) {
-				const failureDetails = vaultsWithIssues.map((v) => `${v.vaultAddress} (${v.failureReasons})`).join("; ");
-				validationIssues.set(index, { message: `Buy offer callback vaults are invalid: ${failureDetails}` });
-			}
-		} catch (_) {}
-		return validationIssues;
-	});
-	return [
-		single("expiry", "Validates that offer has not expired", (offer) => {
-			if (offer.expiry < Math.floor(Date.now() / 1e3)) return { message: "Expiry mismatch" };
-		}),
-		sellErc20CallbackInvalid,
-		buyCallbackVaultInvalid
-	];
+function validity(_parameters) {
+	return [single("expiry", "Validates that offer has not expired", (offer) => {
+		if (offer.expiry < Math.floor(Date.now() / 1e3)) return { message: "Expiry mismatch" };
+	})];
 }
 const chains = ({ chains }) => single("chain_ids", `Validates that offer chain is one of: [${chains.map((c) => c.id).join(", ")}]`, (offer) => {
 	const allowedChainIds = chains.map((c) => c.id);
@@ -5103,12 +4778,10 @@ const maturity = ({ maturities }) => single("maturity", `Validates that offer ma
 	const allowedMaturities = maturities.map((m) => from$11(m));
 	if (!allowedMaturities.includes(offer.maturity)) return { message: `Maturity must be end of current month (${allowedMaturities[0]}) or end of next month (${allowedMaturities[1]}). Got: ${offer.maturity}` };
 });
-const callback = ({ callbacks, allowedAddresses }) => single("callback", `Validates callbacks: buy empty callback is ${callbacks.includes(Type$1.BuyWithEmptyCallback) ? "allowed" : "not allowed"}; sell offers must use a non-empty callback; non-empty callbacks must target one of [${allowedAddresses.map((a) => a.toLowerCase()).join(", ")}]`, (offer) => {
-	if (isEmptyCallback(offer) && offer.buy && !callbacks?.find((c) => c === Type$1.BuyWithEmptyCallback)) return { message: "Buy offers with empty callback not allowed." };
-	if (isEmptyCallback(offer) && !offer.buy) return { message: "Sell offers require a non-empty callback." };
-	if (!isEmptyCallback(offer)) {
-		if (!allowedAddresses.includes(offer.callback.address?.toLowerCase())) return { message: `Callback address ${offer.callback.address} is not allowed.` };
-	}
+const callback = ({ callbacks }) => single("callback", `Validates callbacks: buy empty callback is ${callbacks.includes(Type$1.BuyWithEmptyCallback) ? "allowed" : "not allowed"}; sell empty callback is ${callbacks.includes(Type$1.SellWithEmptyCallback) ? "allowed" : "not allowed"}; non-empty callbacks are rejected`, (offer) => {
+	if (!isEmptyCallback(offer)) return { message: "Non-empty callbacks are not supported." };
+	if (isEmptyCallback(offer) && offer.buy && !callbacks.includes(Type$1.BuyWithEmptyCallback)) return { message: "Buy offers with empty callback not allowed." };
+	if (isEmptyCallback(offer) && !offer.buy && !callbacks.includes(Type$1.SellWithEmptyCallback)) return { message: "Sell offers with empty callback not allowed." };
 });
 /**
 * A validation rule that checks if the offer's tokens are allowed for its chain.
@@ -5173,12 +4846,8 @@ const morphoRules = (chains$2) => {
 		chains({ chains: chains$2 }),
 		maturity({ maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth] }),
 		callback({
-			callbacks: [
-				Type$1.BuyWithEmptyCallback,
-				Type$1.BuyVaultV1Callback,
-				Type$1.SellERC20Callback
-			],
-			allowedAddresses: chains$2.flatMap((c) => getCallbackAddresses(c.name))
+			callbacks: [Type$1.BuyWithEmptyCallback, Type$1.SellWithEmptyCallback],
+			allowedAddresses: []
 		}),
 		token({ assetsByChainId }),
 		oracle({ oraclesByChainId })