@morpho-dev/router 0.7.0 → 0.7.2

package/dist/index.browser.js

@@ -139,6 +139,61 @@ const MetaMorpho = (0, viem.parseAbi)([
 //#region src/core/Abi/MetaMorphoFactory.ts
 const MetaMorphoFactory = (0, viem.parseAbi)(["event CreateMetaMorpho(address indexed metaMorpho,address indexed caller,address initialOwner,uint256 initialTimelock,address indexed asset,string name,string symbol,bytes32 salt)", "function isMetaMorpho(address) view returns (bool)"]);
 
+//#endregion
+//#region src/core/Abi/MorphoV2.ts
+const MorphoV2 = (0, viem.parseAbi)([
+	"constructor()",
+	"function collateralOf(bytes32 id, address user, address collateralToken) view returns (uint256)",
+	"function consume(bytes32 group, uint256 amount)",
+	"function consumed(address user, bytes32 group) view returns (uint256)",
+	"function debtOf(bytes32 id, address user) view returns (uint256)",
+	"function defaultFees(address loanToken, uint256 index) view returns (uint16)",
+	"function feeSetter() view returns (address)",
+	"function fees(bytes32 id) view returns (uint16[6])",
+	"function flashLoan(address token, uint256 assets, address callback, bytes data)",
+	"function isHealthy((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, bytes32 id, address borrower) view returns (bool)",
+	"function liquidate((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, (uint256 collateralIndex, uint256 repaid, uint256 seized)[] seizures, address borrower, bytes data) returns ((uint256 collateralIndex, uint256 repaid, uint256 seized)[])",
+	"function multicall(bytes[] calls)",
+	"function obligationCreated(bytes32 id) view returns (bool)",
+	"function obligationState(bytes32 id) view returns (uint128 totalUnits, uint128 totalShares, uint256 withdrawable, bool created)",
+	"function owner() view returns (address)",
+	"function repay((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, uint256 obligationUnits, address onBehalf)",
+	"function session(address user) view returns (bytes32)",
+	"function setDefaultTradingFee(address loanToken, uint256 index, uint256 newTradingFee)",
+	"function setFeeSetter(address newFeeSetter)",
+	"function setObligationTradingFee(bytes32 id, uint256 index, uint256 newTradingFee)",
+	"function setOwner(address newOwner)",
+	"function setTradingFeeRecipient(address recipient)",
+	"function sharesOf(bytes32 id, address user) view returns (uint256)",
+	"function shuffleSession()",
+	"function supplyCollateral((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, address collateral, uint256 assets, address onBehalf)",
+	"function take(uint256 buyerAssets, uint256 sellerAssets, uint256 obligationUnits, uint256 obligationShares, address taker, ((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, bool buy, address maker, uint256 assets, uint256 obligationUnits, uint256 obligationShares, uint256 start, uint256 expiry, uint256 tick, bytes32 group, bytes32 session, address callback, bytes callbackData) offer, (uint8 v, bytes32 r, bytes32 s) sig, bytes32 root, bytes32[] proof, address takerCallback, bytes takerCallbackData) returns (uint256, uint256, uint256, uint256)",
+	"function totalShares(bytes32 id) view returns (uint256)",
+	"function totalUnits(bytes32 id) view returns (uint256)",
+	"function touchObligation((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation) returns (bytes32)",
+	"function tradingFee(bytes32 id, uint256 timeToMaturity) view returns (uint256)",
+	"function tradingFeeRecipient() view returns (address)",
+	"function withdraw((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, uint256 obligationUnits, uint256 shares, address onBehalf) returns (uint256, uint256)",
+	"function withdrawCollateral((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, address collateral, uint256 assets, address onBehalf)",
+	"function withdrawable(bytes32 id) view returns (uint256)",
+	"event Constructor(address indexed owner)",
+	"event Consume(address indexed user, bytes32 indexed group, uint256 amount)",
+	"event FlashLoan(address indexed caller, address indexed token, uint256 assets)",
+	"event Liquidate(address indexed caller, bytes32 indexed id, (uint256 collateralIndex, uint256 repaid, uint256 seized)[] seizures, address indexed borrower, uint256 totalRepaid, uint256 badDebt)",
+	"event ObligationCreated(bytes32 indexed id, (address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation)",
+	"event Repay(address indexed caller, bytes32 indexed id, uint256 obligationUnits, address indexed onBehalf)",
+	"event SetDefaultTradingFee(address indexed loanToken, uint256 indexed index, uint256 newTradingFee)",
+	"event SetFeeSetter(address indexed feeSetter)",
+	"event SetObligationTradingFee(bytes32 indexed id, uint256 indexed index, uint256 newTradingFee)",
+	"event SetOwner(address indexed owner)",
+	"event SetTradingFeeRecipient(address indexed recipient)",
+	"event ShuffleSession(address indexed user, bytes32 session)",
+	"event SupplyCollateral(address caller, bytes32 indexed id, address indexed collateral, uint256 assets, address indexed onBehalf)",
+	"event Take(address caller, bytes32 indexed id, address indexed maker, address indexed taker, bool offerIsBuy, uint256 buyerAssets, uint256 sellerAssets, uint256 obligationUnits, uint256 obligationShares, bool buyerIsLender, bool sellerIsBorrower, bytes32 group, uint256 consumed)",
+	"event Withdraw(address indexed caller, bytes32 indexed id, uint256 obligationUnits, uint256 shares, address indexed onBehalf)",
+	"event WithdrawCollateral(address caller, bytes32 indexed id, address indexed collateral, uint256 assets, address indexed onBehalf)"
+]);
+
 //#endregion
 //#region src/core/Abi/index.ts
 var Abi_exports = /* @__PURE__ */ __exportAll({
@@ -146,6 +201,7 @@ var Abi_exports = /* @__PURE__ */ __exportAll({
 	MetaMorpho: () => MetaMorpho,
 	MetaMorphoFactory: () => MetaMorphoFactory,
 	Morpho: () => Morpho,
+	MorphoV2: () => MorphoV2,
 	Oracle: () => Oracle
 });
 const Oracle = [{
@@ -294,107 +350,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] = (0, viem.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 (0, viem.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] = (0, viem.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] = (0, viem.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 (0, viem.encodeAbiParameters)([{ type: "address[]" }, { type: "uint256[]" }], [parameters.vaults, parameters.amounts]);
-}
-function encodeSellERC20Callback(parameters) {
-	return (0, viem.encodeAbiParameters)([{ type: "address[]" }, { type: "uint256[]" }], [parameters.collaterals, parameters.amounts]);
-}
 
 //#endregion
 //#region src/utils/BigMath.ts
@@ -644,8 +607,8 @@ const chains$1 = {
 		name: "ethereum-virtual-testnet",
 		custom: {
 			morpho: {
-				address: "0x11a002d45db720ed47a80d2f3489cba5b833eaf5",
-				blockCreated: 0
+				address: "0x634b095371e4e45feed94c1a45c37798e173ea50",
+				blockCreated: 23226700
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -1150,11 +1113,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
 });
@@ -1183,14 +1144,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.
@@ -1200,13 +1153,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) {
@@ -1586,6 +1532,7 @@ var Offer_exports = /* @__PURE__ */ __exportAll({
 	obligationId: () => obligationId,
 	random: () => random$1,
 	serialize: () => serialize,
+	takeEvent: () => takeEvent,
 	toSnakeCase: () => toSnakeCase,
 	types: () => types
 });
@@ -1704,7 +1651,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([
@@ -1731,21 +1678,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: viem.zeroAddress,
-			data: "0x"
-		};
-		const sellCallbackAddress = "0x3333333333333333333333333333333333333333";
-		const amount = assetsScaled * 1000000000000000000000n;
-		return {
-			address: sellCallbackAddress,
-			data: encodeSellERC20Callback({
-				collaterals: [collateralAsset],
-				amounts: [amount]
-			})
-		};
-	})();
+	const emptyCallback = {
+		address: viem.zeroAddress,
+		data: "0x"
+	};
 	return from$9({
 		maker: config?.maker ?? address(),
 		assets: assetsScaled,
@@ -1764,7 +1700,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) => {
@@ -2054,6 +1990,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 = {
@@ -2807,6 +2831,16 @@ const BrandTypeId = Symbol.for("mempool/Brand");
 //#endregion
 //#region src/api/Schema/OfferResponse.ts
 var OfferResponse_exports = /* @__PURE__ */ __exportAll({ from: () => from$2 });
+function normalizeChainId(chainId) {
+	const parsedChainId = Number(chainId);
+	if (!Number.isInteger(parsedChainId) || parsedChainId <= 0) throw new Error(`Invalid chain id: ${String(chainId)}`);
+	return parsedChainId;
+}
+function normalizeBlockNumber(blockNumber) {
+	const parsedBlockNumber = Number(blockNumber);
+	if (!Number.isInteger(parsedBlockNumber) || parsedBlockNumber < 0) throw new Error(`Invalid block number: ${String(blockNumber)}`);
+	return parsedBlockNumber;
+}
 /**
 * Creates an `OfferResponse` matching the Solidity Offer struct layout.
 * @constructor
@@ -2814,6 +2848,8 @@ var OfferResponse_exports = /* @__PURE__ */ __exportAll({ from: () => from$2 });
 * @returns The created `OfferResponse`. {@link OfferResponse}
 */
 function from$2(input) {
+	const chainId = normalizeChainId(input.chainId);
+	const blockNumber = normalizeBlockNumber(input.blockNumber);
 	const base = {
 		offer: {
 			obligation: {
@@ -2840,15 +2876,15 @@ function from$2(input) {
 		},
 		offer_hash: input.hash,
 		obligation_id: id({
-			chainId: input.chainId,
+			chainId,
 			loanToken: input.loanToken,
 			collaterals: [...input.collaterals],
 			maturity: input.maturity
 		}),
-		chain_id: input.chainId,
+		chain_id: chainId,
 		consumed: input.consumed.toString(),
 		takeable: input.takeable.toString(),
-		block_number: input.blockNumber
+		block_number: blockNumber
 	};
 	if (!input.proof || !input.root || !input.signature) return {
 		...base,
@@ -2908,8 +2944,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",
@@ -2961,25 +2997,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,
@@ -3048,55 +3069,6 @@ __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
 	example: validateOfferExample.callback.data
 })], ValidateCallbackRequest.prototype, "data", void 0);
-var CallbackTypesChainRequest = class {};
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: "number",
-	example: callbackTypesRequestExample.callbacks[0].chain_id
-})], CallbackTypesChainRequest.prototype, "chain_id", void 0);
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: () => [String],
-	example: callbackTypesRequestExample.callbacks[0].addresses
-})], CallbackTypesChainRequest.prototype, "addresses", void 0);
-var CallbackTypesRequest = class {};
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: () => [CallbackTypesChainRequest],
-	example: callbackTypesRequestExample.callbacks
-})], CallbackTypesRequest.prototype, "callbacks", void 0);
-var CallbackTypesChainResponse = class {};
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: "number",
-	example: callbackTypesResponseExample[0].chain_id
-})], CallbackTypesChainResponse.prototype, "chain_id", void 0);
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].buy_vault_v1_callback
-})], CallbackTypesChainResponse.prototype, "buy_vault_v1_callback", void 0);
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].sell_erc20_callback
-})], CallbackTypesChainResponse.prototype, "sell_erc20_callback", void 0);
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].buy_erc20
-})], CallbackTypesChainResponse.prototype, "buy_erc20", void 0);
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: () => [String],
-	example: callbackTypesResponseExample[0].not_supported
-})], CallbackTypesChainResponse.prototype, "not_supported", void 0);
-var CallbackTypesSuccessResponse = class extends SuccessResponse {};
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: "string",
-	nullable: true,
-	example: "maturity:1:1730415600:end_of_next_month"
-})], CallbackTypesSuccessResponse.prototype, "cursor", void 0);
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: () => [CallbackTypesChainResponse],
-	description: "Callback types grouped by chain.",
-	example: callbackTypesResponseExample
-})], CallbackTypesSuccessResponse.prototype, "data", void 0);
 var AskResponse = class {};
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
@@ -3614,7 +3586,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."
 	}),
 	(0, openapi_metadata_decorators.ApiBody)({ type: ValidateOffersRequest }),
 	(0, openapi_metadata_decorators.ApiResponse)({
@@ -3633,28 +3605,6 @@ ValidateController = __decorate([(0, openapi_metadata_decorators.ApiTags)("Make"
 	description: "Bad Request",
 	type: BadRequestResponse
 })], ValidateController);
-let CallbacksController = class CallbacksController {
-	async resolveCallbackTypes() {}
-};
-__decorate([
-	(0, openapi_metadata_decorators.ApiOperation)({
-		methods: ["post"],
-		path: "/v1/callbacks",
-		summary: "Resolve callback types",
-		description: "Returns callback types for callback addresses grouped by chain."
-	}),
-	(0, openapi_metadata_decorators.ApiBody)({ type: CallbackTypesRequest }),
-	(0, openapi_metadata_decorators.ApiResponse)({
-		status: 200,
-		description: "Success",
-		type: CallbackTypesSuccessResponse
-	})
-], CallbacksController.prototype, "resolveCallbackTypes", null);
-CallbacksController = __decorate([(0, openapi_metadata_decorators.ApiTags)("Make"), (0, openapi_metadata_decorators.ApiResponse)({
-	status: 400,
-	description: "Bad Request",
-	type: BadRequestResponse
-})], CallbacksController);
 let OffersController = class OffersController {
 	async getOffers() {}
 };
@@ -3804,12 +3754,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,
@@ -3823,7 +3767,6 @@ const configRulesOracleExample = {
 const configRulesChecksumExample = "f1d2d2f924e986ac86fdf7b36c94bcdf";
 const configRulesPayloadExample = [
 	configRulesMaturityExample,
-	configRulesCallbackExample,
 	configRulesLoanTokenExample,
 	configRulesOracleExample
 ];
@@ -3888,14 +3831,9 @@ __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 })], ConfigRulesRuleResponse.prototype, "timestamp", void 0);
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
-	example: configRulesCallbackExample.address,
+	example: configRulesLoanTokenExample.address,
 	required: false
 })], ConfigRulesRuleResponse.prototype, "address", void 0);
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: "string",
-	example: configRulesCallbackExample.callback_type,
-	required: false
-})], ConfigRulesRuleResponse.prototype, "callback_type", void 0);
 var ConfigRulesSuccessResponse = class {};
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({ type: () => ConfigRulesMeta })], ConfigRulesSuccessResponse.prototype, "meta", void 0);
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
@@ -3956,7 +3894,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."
 	}),
 	(0, openapi_metadata_decorators.ApiQuery)({
 		name: "cursor",
@@ -4135,8 +4073,7 @@ const OpenApi = async () => {
 			ObligationsController,
 			HealthController,
 			UsersController,
-			ValidateController,
-			CallbacksController
+			ValidateController
 		],
 		document: {
 			openapi: "3.1.0",
@@ -4393,16 +4330,6 @@ const GetBookParams = zod.object({
 	})
 });
 const ValidateOffersBody = zod.object({ offers: zod.array(zod.unknown()).min(1, { message: "'offers' must contain at least 1 offer" }) }).strict();
-const CallbackTypesBody = zod.object({ callbacks: zod.array(zod.object({
-	chain_id: zod.number().int().positive().meta({
-		description: "Chain id.",
-		example: 1
-	}),
-	addresses: zod.array(zod.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 = zod.object({
 	...PaginationQueryParams.shape,
 	user_address: zod.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "User address must be a valid 20-byte address" }).transform((val) => val.toLowerCase()).meta({
@@ -4421,7 +4348,6 @@ const schemas = {
 	get_obligation: GetObligationParams,
 	get_book: GetBookParams,
 	validate_offers: ValidateOffersBody,
-	callback_types: CallbackTypesBody,
 	get_user_positions: GetUserPositionsParams
 };
 function parse(action, query) {
@@ -4436,7 +4362,6 @@ function safeParse(action, query, error) {
 var Schema_exports = /* @__PURE__ */ __exportAll({
 	BookResponse: () => BookResponse_exports,
 	BooksController: () => BooksController,
-	CallbacksController: () => CallbacksController,
 	ChainHealth: () => ChainHealth,
 	ChainsHealthResponse: () => ChainsHealthResponse,
 	CollectorHealth: () => CollectorHealth,
@@ -4715,23 +4640,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) {
@@ -4855,36 +4768,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",
@@ -4956,63 +4839,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]
 	}
 };
@@ -5032,109 +4871,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 (0, viem_actions.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);
@@ -5144,12 +4887,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.
@@ -5214,12 +4955,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 })