@morpho-dev/router 0.7.1 → 0.7.2

package/dist/index.node.mjs

@@ -949,6 +949,61 @@ const MetaMorpho = parseAbi([
 //#region src/core/Abi/MetaMorphoFactory.ts
 const MetaMorphoFactory = 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 = 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({
@@ -956,6 +1011,7 @@ var Abi_exports = /* @__PURE__ */ __exportAll({
 	MetaMorpho: () => MetaMorpho,
 	MetaMorphoFactory: () => MetaMorphoFactory,
 	Morpho: () => Morpho,
+	MorphoV2: () => MorphoV2,
 	Oracle: () => Oracle
 });
 const Oracle = [{
@@ -1217,8 +1273,8 @@ const chains$2 = {
 		name: "ethereum-virtual-testnet",
 		custom: {
 			morpho: {
-				address: "0x11a002d45db720ed47a80d2f3489cba5b833eaf5",
-				blockCreated: 0
+				address: "0x634b095371e4e45feed94c1a45c37798e173ea50",
+				blockCreated: 23226700
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -5182,6 +5238,16 @@ function from$4(obligation, quote) {
 //#endregion
 //#region src/api/Schema/OfferResponse.ts
 var OfferResponse_exports = /* @__PURE__ */ __exportAll({ from: () => from$3 });
+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
@@ -5189,6 +5255,8 @@ var OfferResponse_exports = /* @__PURE__ */ __exportAll({ from: () => from$3 });
 * @returns The created `OfferResponse`. {@link OfferResponse}
 */
 function from$3(input) {
+	const chainId = normalizeChainId(input.chainId);
+	const blockNumber = normalizeBlockNumber(input.blockNumber);
 	const base = {
 		offer: {
 			obligation: {
@@ -5215,15 +5283,15 @@ function from$3(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,
@@ -6793,12 +6861,34 @@ async function getBook(params, db) {
 	if (!result.success) return failure(result.error);
 	const query = result.data;
 	try {
+		logger.debug({
+			service: "api_controller",
+			endpoint: "get_book",
+			msg: "Loading book levels",
+			obligation_id: query.obligation_id,
+			side: query.side,
+			limit: query.limit ?? null,
+			has_cursor: query.cursor != null
+		});
 		const { levels, nextCursor } = await db.book.get({
 			side: query.side,
 			obligationId: query.obligation_id,
 			cursor: query.cursor,
 			limit: query.limit
 		});
+		const firstLevel = levels[0];
+		logger.debug({
+			service: "api_controller",
+			endpoint: "get_book",
+			msg: "Loaded book levels",
+			obligation_id: query.obligation_id,
+			side: query.side,
+			levels_count: levels.length,
+			has_next_cursor: nextCursor != null,
+			first_level_price: firstLevel?.price.toString() ?? null,
+			first_level_assets: firstLevel?.assets.toString() ?? null,
+			first_level_count: firstLevel?.count ?? null
+		});
 		return success({
 			data: levels.map(from$5),
 			cursor: nextCursor
@@ -7686,16 +7776,57 @@ async function getOffersQuery(db, parameters) {
         '[]'::jsonb
       )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles$1, sql`${obligationCollateralsV2.oracleChainId} = ${oracles$1.chainId}
              AND ${obligationCollateralsV2.oracleAddress} = ${oracles$1.address}`).where(eq(obligationCollateralsV2.obligationId, offers.obligationId)).as("collaterals_lateral");
-	const availableLateral = db.select({ available: sql`COALESCE(SUM(
-            CASE
-              WHEN ${positions.asset} IS NULL THEN 0
-              ELSE
-                CASE
-                  WHEN ${callbacks.amount} IS NULL THEN COALESCE(${positions.balance}, 0)::numeric
-                  ELSE LEAST(${callbacks.amount}::numeric, COALESCE(${positions.balance}, 0)::numeric)
-                END
-            END
-          ), 0)`.as("available") }).from(offersCallbacks).innerJoin(callbacks, eq(offersCallbacks.callbackId, callbacks.id)).innerJoin(positions, and(eq(callbacks.positionChainId, positions.chainId), eq(callbacks.positionContract, positions.contract), eq(callbacks.positionUser, positions.user))).where(eq(offersCallbacks.offerHash, offers.hash)).as("available_lateral");
+	const lotBalanceExpr = sql`GREATEST(0, LEAST(
+      COALESCE(${positions.balance}, 0)::numeric
+        + COALESCE((
+            SELECT SUM(${offsets.value}::numeric)
+            FROM ${offsets}
+            WHERE ${offsets.chainId} = ${callbacks.positionChainId}
+              AND LOWER(${offsets.contract}) = LOWER(${callbacks.positionContract})
+              AND LOWER(${offsets.user}) = LOWER(${callbacks.positionUser})
+          ), 0)
+        - COALESCE(${lots.lower}::numeric, 0),
+      (COALESCE(${lots.upper}::numeric, 0) - COALESCE(${lots.lower}::numeric, 0))
+        - CASE
+            WHEN ${offers.assets}::numeric > 0
+            THEN COALESCE(${groups.consumed}::numeric, 0)
+              * (COALESCE(${lots.upper}::numeric, 0) - COALESCE(${lots.lower}::numeric, 0))
+              / ${offers.assets}::numeric
+            ELSE 0
+          END
+    ))`;
+	const contributionExpr = sql`CASE
+      WHEN ${positions.asset} IS NULL OR ${lots.lower} IS NULL THEN 0
+      ELSE LEAST(COALESCE(${callbacks.amount}::numeric, ${lotBalanceExpr}), ${lotBalanceExpr})
+    END`;
+	const availableExpr = sql`COALESCE((
+      SELECT SUM(deduped.contribution)
+      FROM (
+        SELECT DISTINCT ON (
+          ${callbacks.positionChainId},
+          LOWER(${callbacks.positionContract}),
+          LOWER(${callbacks.positionUser})
+        )
+          ${contributionExpr} AS contribution
+        FROM ${offersCallbacks}
+        INNER JOIN ${callbacks} ON ${offersCallbacks.callbackId} = ${callbacks.id}
+        LEFT JOIN ${positions}
+          ON ${positions.chainId} = ${callbacks.positionChainId}
+          AND LOWER(${positions.contract}) = LOWER(${callbacks.positionContract})
+          AND LOWER(${positions.user}) = LOWER(${callbacks.positionUser})
+        LEFT JOIN ${lots}
+          ON ${lots.chainId} = ${callbacks.positionChainId}
+          AND LOWER(${lots.contract}) = LOWER(${callbacks.positionContract})
+          AND LOWER(${lots.user}) = LOWER(${callbacks.positionUser})
+          AND LOWER(${lots.group}) = LOWER(${offers.group})
+        WHERE ${offersCallbacks.offerHash} = ${offers.hash}
+        ORDER BY
+          ${callbacks.positionChainId},
+          LOWER(${callbacks.positionContract}),
+          LOWER(${callbacks.positionUser}),
+          ${contributionExpr} DESC
+      ) deduped
+    ), 0)`;
 	const rows = (await db.select({
 		hash: offers.hash,
 		maker: offers.groupMaker,
@@ -7716,22 +7847,22 @@ async function getOffersQuery(db, parameters) {
 		callbackData: offers.callbackData,
 		collaterals: collateralsLateral.collaterals,
 		blockNumber: offers.blockNumber,
-		available: sql`COALESCE(${availableLateral.available}::numeric, 0)`.as("available"),
+		available: sql`${availableExpr}::numeric`.as("available"),
 		takeable: sql`FLOOR(GREATEST(0,
             CASE WHEN ${offers.buy} = false
               THEN ${offers.assets}::numeric - ${groups.consumed}::numeric
               ELSE LEAST(
                 ${offers.assets}::numeric - ${groups.consumed}::numeric,
-                COALESCE(${availableLateral.available}::numeric, 0)
+                ${availableExpr}::numeric
               )
             END
           ))`.as("takeable")
-	}).from(offers).innerJoin(obligations, eq(offers.obligationId, obligations.obligationId)).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).innerJoinLateral(collateralsLateral, sql`true`).leftJoinLateral(availableLateral, sql`true`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0, gte(offers.expiry, now), gte(offers.maturity, now), maker === void 0 ? sql`GREATEST(0,
+	}).from(offers).innerJoin(obligations, eq(offers.obligationId, obligations.obligationId)).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).innerJoinLateral(collateralsLateral, sql`true`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0, gte(offers.expiry, now), gte(offers.maturity, now), maker === void 0 ? sql`GREATEST(0,
                   CASE WHEN ${offers.buy} = false
                     THEN ${offers.assets}::numeric - ${groups.consumed}::numeric
                     ELSE LEAST(
                       ${offers.assets}::numeric - ${groups.consumed}::numeric,
-                      COALESCE(${availableLateral.available}::numeric, 0)
+                      ${availableExpr}::numeric
                     )
                   END
                 ) > 0` : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {