@morpho-dev/router 0.1.9 → 0.1.11

package/dist/index.node.js

@@ -724,54 +724,147 @@ function fromResponse(offerResponse) {
 var Callback_exports = {};
 __export(Callback_exports, {
   CallbackType: () => CallbackType,
+  WhitelistedCallbackAddresses: () => WhitelistedCallbackAddresses,
   buildLiquidity: () => buildLiquidity,
+  decode: () => decode2,
+  encode: () => encode2,
   getCallbackIdForOffer: () => getCallbackIdForOffer
 });
 var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
   CallbackType2["BuyWithEmptyCallback"] = "buy_with_empty_callback";
+  CallbackType2["SellWithdrawFromWallet"] = "sell_withdraw_from_wallet";
   return CallbackType2;
 })(CallbackType || {});
+var WhitelistedCallbackAddresses = {
+  ["buy_with_empty_callback" /* BuyWithEmptyCallback */]: [],
+  ["sell_withdraw_from_wallet" /* SellWithdrawFromWallet */]: [
+    "0x1111111111111111111111111111111111111111",
+    "0x2222222222222222222222222222222222222222"
+    // @TODO: update once deployed and add mapping per chain if needed
+  ].map((address) => address.toLowerCase())
+};
 function buildLiquidity(parameters) {
-  const { type, user, contract, chainId, amount, index: index2 = 0, updatedAt = /* @__PURE__ */ new Date() } = parameters;
-  if (type !== "buy_with_empty_callback" /* BuyWithEmptyCallback */)
-    throw new Error(`CallbackType not implemented: ${type}`);
-  const amountStr = amount.toString();
-  const id = `${user}-${chainId.toString()}-${type}-${contract}`.toLowerCase();
-  return {
-    userPosition: {
-      id,
-      availableLiquidityQueueId: id,
-      user: user.toLowerCase(),
-      chainId,
-      amount: amountStr,
-      updatedAt
-    },
-    queues: [
-      {
-        queue: {
-          queueId: id,
-          availableLiquidityPoolId: id,
-          index: index2,
+  switch (parameters.type) {
+    case "buy_with_empty_callback" /* BuyWithEmptyCallback */: {
+      const { user, loanToken, chainId, amount, index: index2 = 0, updatedAt = /* @__PURE__ */ new Date() } = parameters;
+      const amountStr = amount.toString();
+      const id = `${user}-${chainId.toString()}-${parameters.type}-${loanToken}`.toLowerCase();
+      const poolId = `${user}-${chainId.toString()}-${loanToken}`.toLowerCase();
+      return {
+        userPosition: {
+          id,
+          availableLiquidityQueueId: id,
+          user: user.toLowerCase(),
+          chainId,
+          amount: amountStr,
           updatedAt
         },
-        pool: {
+        queues: [
+          {
+            queue: {
+              queueId: id,
+              availableLiquidityPoolId: poolId,
+              index: index2,
+              callbackAmount: "0",
+              updatedAt
+            },
+            pool: {
+              id: poolId,
+              amount: amountStr,
+              updatedAt
+            }
+          }
+        ]
+      };
+    }
+    case "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */: {
+      const {
+        user,
+        termId,
+        chainId,
+        amount,
+        collaterals,
+        index: index2 = 0,
+        updatedAt = /* @__PURE__ */ new Date()
+      } = parameters;
+      const amountStr = amount.toString();
+      const id = `${user}-${chainId.toString()}-${parameters.type}-${termId}`.toLowerCase();
+      return {
+        userPosition: {
           id,
+          availableLiquidityQueueId: id,
+          user: user.toLowerCase(),
+          chainId,
           amount: amountStr,
           updatedAt
-        }
-      }
-    ]
-  };
+        },
+        queues: collaterals.map((collateral) => {
+          const poolId = `${user}-${chainId.toString()}-${collateral.collateralAddress}`.toLowerCase();
+          return {
+            queue: {
+              queueId: id,
+              availableLiquidityPoolId: poolId,
+              index: index2,
+              callbackAmount: collateral.callbackAmount.toString(),
+              updatedAt
+            },
+            pool: {
+              id: poolId,
+              amount: collateral.balance.toString(),
+              updatedAt
+            }
+          };
+        })
+      };
+    }
+    default: {
+      throw new Error(`CallbackType not implemented`);
+    }
+  }
 }
 function getCallbackIdForOffer(offer) {
   if (offer.buy && offer.callback.data === "0x") {
-    const type = "buy_with_empty_callback" /* BuyWithEmptyCallback */;
-    const user = offer.offering;
-    const loanToken = offer.loanToken;
-    return `${user}-${offer.chainId.toString()}-${type}-${loanToken}`.toLowerCase();
+    return `${offer.offering}-${offer.chainId.toString()}-${"buy_with_empty_callback" /* BuyWithEmptyCallback */}-${offer.loanToken}`.toLowerCase();
+  }
+  if (!offer.buy && offer.callback.data !== "0x" && WhitelistedCallbackAddresses["sell_withdraw_from_wallet" /* SellWithdrawFromWallet */].includes(
+    offer.callback.address.toLowerCase()
+  )) {
+    return `${offer.offering}-${offer.chainId.toString()}-${"sell_withdraw_from_wallet" /* SellWithdrawFromWallet */}-${mempool.Offer.termId(offer)}`.toLowerCase();
   }
   return null;
 }
+function decodeSellWithdrawFromWalletData(data) {
+  if (!data || data === "0x") throw new Error("Empty callback data");
+  try {
+    const [collaterals, amounts] = viem.decodeAbiParameters(
+      [{ type: "address[]" }, { type: "uint256[]" }],
+      data
+    );
+    if (collaterals.length !== amounts.length) {
+      throw new Error("Mismatched array lengths");
+    }
+    return collaterals.map((c, i) => ({ collateral: c, amount: amounts[i] }));
+  } catch (_) {
+    throw new Error("Invalid SellWithdrawFromWallet callback data");
+  }
+}
+function decode2(parameters) {
+  const { type, data } = parameters;
+  if (type === "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */) {
+    return decodeSellWithdrawFromWalletData(data);
+  }
+  throw new Error(`CallbackType not implemented: ${type}`);
+}
+function encode2(parameters) {
+  const { type, data } = parameters;
+  if (type === "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */) {
+    return viem.encodeAbiParameters(
+      [{ type: "address[]" }, { type: "uint256[]" }],
+      [data.collaterals, data.amounts]
+    );
+  }
+  throw new Error(`CallbackType not implemented: ${type}`);
+}
 
 // src/core/Collector/index.ts
 var Collector_exports = {};
@@ -856,20 +949,20 @@ async function fetch2(parameters) {
   const map = await fetchBalancesAndAllowances({
     client,
     spender,
-    pairs: pairs.map(({ user, contract }) => ({ user, token: contract })),
+    pairs: pairs.map(({ user, loanToken }) => ({ user, token: loanToken })),
     options
   });
   const out = [];
-  for (const [user, perContract] of map) {
-    for (const [contract, { balance, allowance }] of perContract) {
+  for (const [user, perLoanToken] of map) {
+    for (const [loanToken, { balance, allowance }] of perLoanToken) {
       const amount = balance < allowance ? balance : allowance;
       out.push(
         buildLiquidity({
           type,
           user,
-          contract,
+          loanToken,
           chainId,
-          amount: amount.toString(),
+          amount,
           index: 0
         })
       );
@@ -927,16 +1020,16 @@ __export(Logger_exports, {
   silentLogger: () => silentLogger
 });
 var LogLevelValues = [
-  "silent",
   "trace",
   "debug",
   "info",
   "warn",
   "error",
-  "fatal"
+  "fatal",
+  "silent"
 ];
 function defaultLogger(minLevel) {
-  const threshold = minLevel ?? "info";
+  const threshold = minLevel ?? process.env.ROUTER_LOG_LEVEL ?? "info";
   const levelIndexByName = LogLevelValues.reduce(
     (acc, lvl, idx) => {
       acc[lvl] = idx;
@@ -1032,7 +1125,7 @@ function createBuyWithEmptyCallbackLiquidityCollector(params) {
           chainId: chain.id,
           spender: chain.morpho,
           type: "buy_with_empty_callback" /* BuyWithEmptyCallback */,
-          pairs: pairs.map(({ user, token }) => ({ user, contract: token })),
+          pairs: pairs.map(({ user, token }) => ({ user, loanToken: token })),
           options: {
             blockNumber: latestBlockNumber,
             batchSize: maxBatchSize
@@ -1083,14 +1176,15 @@ function createBuyWithEmptyCallbackLiquidityCollector(params) {
   };
 }
 function createChainReorgsCollector(parameters) {
-  const collectorName = "chain_reorgs";
+  const collector = "chain_reorgs";
   const {
     client,
     subscribers,
     collectorStore,
     chain,
-    options: { maxBatchSize = 25, interval } = {}
+    options: { maxBatchSize = 25, interval = 3e4, maxBlockNumber } = {}
   } = parameters;
+  const maxBlockNumberBI = maxBlockNumber !== void 0 ? BigInt(maxBlockNumber) : void 0;
   let finalizedBlock = null;
   let unfinalizedBlocks = [];
   const commonAncestor = (block) => {
@@ -1099,67 +1193,79 @@ function createChainReorgsCollector(parameters) {
     if (finalizedBlock == null) throw new Error("Failed to get common ancestor");
     return finalizedBlock;
   };
-  const reconcile = async (block) => {
-    if (block.hash === null || block.number === null || block.parentHash === null)
-      throw new Error("Failed to get block");
-    const latestBlock = unfinalizedBlocks[unfinalizedBlocks.length - 1];
-    if (latestBlock === void 0) {
-      unfinalizedBlocks.push({
+  const collect = mempool.Utils.lazy((emit, { stop }) => {
+    const logger = getLogger();
+    const reconcile = async (block) => {
+      if (block.hash === null || block.number === null || block.parentHash === null)
+        throw new Error("Failed to get block");
+      const latestBlock = unfinalizedBlocks[unfinalizedBlocks.length - 1];
+      if (latestBlock === void 0) {
+        const newBlock2 = {
+          hash: block.hash,
+          number: block.number,
+          parentHash: block.parentHash
+        };
+        unfinalizedBlocks.push(newBlock2);
+        return newBlock2;
+      }
+      if (latestBlock.hash === block.hash) return latestBlock;
+      if (latestBlock.number >= block.number) {
+        const ancestor = commonAncestor(block);
+        logger.info({
+          collector,
+          chainId: chain.id,
+          msg: `reorg detected, latestBlock.number: ${latestBlock.number} >= block.number: ${block.number} on chain ${chain.id}. Ancestor: ${ancestor.number}`
+        });
+        subscribers.forEach((subscriber) => subscriber.onReorg(Number(ancestor.number)));
+        unfinalizedBlocks = [];
+        return ancestor;
+      }
+      if (latestBlock.number + 1n < block.number) {
+        logger.debug({
+          collector,
+          chainId: chain.id,
+          msg: `missing blocks between block ${latestBlock.number} and block ${block.number} on chain ${chain.id}`
+        });
+        const missingBlockNumbers = (() => {
+          const missingBlockNumbers2 = [];
+          let start2 = latestBlock.number + 1n;
+          const threshold = latestBlock.number + BigInt(maxBatchSize) > block.number ? block.number : latestBlock.number + BigInt(maxBatchSize);
+          while (start2 < threshold) {
+            missingBlockNumbers2.push(start2);
+            start2 = start2 + 1n;
+          }
+          return missingBlockNumbers2;
+        })();
+        const missingBlocks = await Promise.all(
+          missingBlockNumbers.map(
+            (blockNumber) => client.getBlock({ blockNumber, includeTransactions: false })
+          )
+        );
+        for (const missingBlock of missingBlocks) {
+          const returnedBlock = await reconcile(missingBlock);
+          if (returnedBlock.number !== missingBlock.number) return returnedBlock;
+        }
+        return reconcile(block);
+      }
+      if (block.parentHash !== latestBlock.hash) {
+        const ancestor = commonAncestor(block);
+        logger.info({
+          collector,
+          chainId: chain.id,
+          msg: `reorg detected, block.parentHash: ${block.parentHash} !== latestBlock.hash: ${latestBlock.hash} on chain ${chain.id}. Ancestor: ${ancestor.number}`
+        });
+        subscribers.forEach((subscriber) => subscriber.onReorg(Number(ancestor.number)));
+        unfinalizedBlocks = [];
+        return ancestor;
+      }
+      const newBlock = {
         hash: block.hash,
         number: block.number,
         parentHash: block.parentHash
-      });
-      return;
-    }
-    if (latestBlock.hash === block.hash) return;
-    if (latestBlock.number >= block.number) {
-      const ancestor = commonAncestor(block);
-      console.log(
-        `reorg detected, latestBlock.number: ${latestBlock.number} > block.number: ${block.number} on chain ${chain.id}. Ancestor: ${ancestor.number}`
-      );
-      subscribers.forEach((subscriber) => subscriber.onReorg(Number(ancestor.number)));
-      unfinalizedBlocks = [];
-      return;
-    }
-    if (latestBlock.number + 1n < block.number) {
-      console.log(
-        `missing blocks between block ${latestBlock.number} and block ${block.number} on chain ${chain.id}`
-      );
-      const missingBlockNumbers = (() => {
-        const missingBlockNumbers2 = [];
-        let start2 = latestBlock.number + 1n;
-        const threshold = latestBlock.number + BigInt(maxBatchSize) > block.number ? block.number : latestBlock.number + BigInt(maxBatchSize);
-        while (start2 < threshold) {
-          missingBlockNumbers2.push(start2);
-          start2 = start2 + 1n;
-        }
-        return missingBlockNumbers2;
-      })();
-      const missingBlocks = await Promise.all(
-        missingBlockNumbers.map(
-          (blockNumber) => client.getBlock({ blockNumber, includeTransactions: false })
-        )
-      );
-      for (const missingBlock of missingBlocks) await reconcile(missingBlock);
-      await reconcile(block);
-      return;
-    }
-    if (block.parentHash !== latestBlock.hash) {
-      const ancestor = commonAncestor(block);
-      console.log(
-        `reorg detected, block.parentHash: ${block.parentHash} !== latestBlock.hash: ${latestBlock.hash} on chain ${chain.id}. Ancestor: ${ancestor.number}`
-      );
-      subscribers.forEach((subscriber) => subscriber.onReorg(Number(ancestor.number)));
-      unfinalizedBlocks = [];
-      return;
-    }
-    unfinalizedBlocks.push({
-      hash: block.hash,
-      number: block.number,
-      parentHash: block.parentHash
-    });
-  };
-  const collect = mempool.Utils.lazy((emit) => {
+      };
+      unfinalizedBlocks.push(newBlock);
+      return newBlock;
+    };
     let tick = 0;
     const fetchFinalizedBlock = async () => {
       if (tick % 20 === 0 || finalizedBlock === null) {
@@ -1167,32 +1273,58 @@ function createChainReorgsCollector(parameters) {
           blockTag: "finalized",
           includeTransactions: false
         });
-        if (finalizedBlock === null) throw new Error("Failed to get finalized block");
+        if (finalizedBlock === null) {
+          const msg = "Failed to get finalized block";
+          logger.fatal({ collector, chainId: chain.id, msg });
+          throw new Error(msg);
+        }
+        unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number >= finalizedBlock.number);
       }
       tick++;
     };
-    return mempool.Utils.poll(
+    let isMaxBlockNumberReached = false;
+    const unpoll = mempool.Utils.poll(
       async () => {
-        await fetchFinalizedBlock();
-        const latestBlock = await client.getBlock({
+        if (isMaxBlockNumberReached) {
+          stop();
+          return;
+        }
+        const head = await client.getBlock({
           blockTag: "latest",
           includeTransactions: false
         });
-        await reconcile(latestBlock);
-        const lastBlockNumber = Number(latestBlock.number);
+        if (maxBlockNumberBI !== void 0 && head.number >= maxBlockNumberBI) {
+          logger.info({
+            collector,
+            chainId: chain.id,
+            msg: `head is greater than max block number, head.number: ${head.number} > maxBlockNumber: ${maxBlockNumber} on chain ${chain.id}.`
+          });
+          isMaxBlockNumberReached = true;
+          subscribers.forEach((subscriber) => subscriber.onReorg(maxBlockNumber));
+          await collectorStore.saveBlockNumber({
+            collectorName: collector,
+            chainId: chain.id,
+            blockNumber: maxBlockNumber
+          });
+          emit(maxBlockNumber);
+          return;
+        }
+        await fetchFinalizedBlock();
+        const blockNumber = Number((await reconcile(head)).number);
         await collectorStore.saveBlockNumber({
-          collectorName: "chain_reorgs",
+          collectorName: collector,
           chainId: chain.id,
-          blockNumber: lastBlockNumber
+          blockNumber
         });
-        emit(lastBlockNumber);
+        emit(blockNumber);
       },
       { interval: interval ?? 3e4 }
     );
+    return unpoll;
   });
   return {
-    name: collectorName,
-    lastSyncedBlock: async () => await collectorStore.getBlockNumber({ collectorName, chainId: chain.id }),
+    name: collector,
+    lastSyncedBlock: async () => await collectorStore.getBlockNumber({ collectorName: collector, chainId: chain.id }),
     collect,
     onReorg: (_) => {
     }
@@ -1391,18 +1523,89 @@ function morpho() {
       return { message: "Expiry mismatch" };
     }
   });
-  const callback = single("empty_callback", (offer, _) => {
-    if (!offer.buy || offer.callback.data !== "0x") {
-      return { message: "Callback not supported yet." };
+  const sellEmptyCallback = single(
+    "sell_offers_empty_callback",
+    (offer, _) => {
+      if (!offer.buy && offer.callback.data === "0x") {
+        return { message: "Sell offers require a non-empty callback." };
+      }
     }
-  });
+  );
+  const buyNonEmptyCallback = single(
+    "buy_offers_non_empty_callback",
+    (offer, _) => {
+      if (offer.buy && offer.callback.data !== "0x") {
+        return { message: "Buy offers must use an empty callback." };
+      }
+    }
+  );
+  const sellNonWhitelistedCallback = single(
+    "sell_offers_non_whitelisted_callback",
+    (offer, _) => {
+      if (!offer.buy && offer.callback.data !== "0x") {
+        const allowed = new Set(
+          WhitelistedCallbackAddresses["sell_withdraw_from_wallet" /* SellWithdrawFromWallet */].map(
+            (a) => a.toLowerCase()
+          )
+        );
+        const callbackAddress = offer.callback.address?.toLowerCase();
+        if (!callbackAddress || !allowed.has(callbackAddress)) {
+          return { message: "Sell offer callback address is not whitelisted." };
+        }
+      }
+    }
+  );
+  const sellCallbackDataInvalid = single(
+    "sell_offers_callback_data_invalid",
+    (offer, _) => {
+      if (!offer.buy && offer.callback.data !== "0x") {
+        try {
+          const decoded = decode2({
+            type: "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */,
+            data: offer.callback.data
+          });
+          if (decoded.length === 0) {
+            return { message: "Sell offer callback data must include at least one collateral." };
+          }
+        } catch (_2) {
+          return { message: "Sell offer callback data cannot be decoded." };
+        }
+      }
+    }
+  );
+  const sellCallbackCollateralInvalid = single(
+    "sell_offers_callback_collateral_invalid",
+    (offer, _) => {
+      if (!offer.buy && offer.callback.data !== "0x") {
+        try {
+          const decoded = decode2({
+            type: "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */,
+            data: offer.callback.data
+          });
+          const offerCollaterals2 = new Set(
+            offer.collaterals.map((c) => c.asset.toLowerCase())
+          );
+          for (const { collateral } of decoded) {
+            if (!offerCollaterals2.has(collateral.toLowerCase())) {
+              return { message: "Sell callback collateral is not part of offer collaterals." };
+            }
+          }
+        } catch (_2) {
+        }
+      }
+    }
+  );
   return [
     chainId,
     loanToken,
     expiry,
-    // note: callback rule should be the last one, since it does not mean that the offer is forever invalid
+    // note: callback rules should be the last ones, since they do not mean that the offer is forever invalid
     // integrators should be able to choose if they want to keep the offer or not
-    callback
+    sellEmptyCallback,
+    buyNonEmptyCallback,
+    sellNonWhitelistedCallback,
+    sellCallbackDataInvalid,
+    sellCallbackCollateralInvalid
   ];
 }
 
@@ -1451,9 +1654,11 @@ function createMempoolCollector(parameters) {
           });
           const invalidOffersToSave = [];
           const issueToStatus = {
-            empty_callback: "callback_not_supported",
             sell_offers_empty_callback: "callback_not_supported",
-            buy_offers_empty_callback: "callback_error"
+            buy_offers_non_empty_callback: "callback_not_supported",
+            sell_offers_non_whitelisted_callback: "callback_not_supported",
+            sell_offers_callback_data_invalid: "callback_error",
+            sell_offers_callback_collateral_invalid: "callback_error"
           };
           for (const issue of issues) {
             const status = issueToStatus[issue.ruleName];
@@ -1564,11 +1769,19 @@ var offers = s.table(
     pgCore.index("offers_expiry_idx").on(table.expiry),
     pgCore.index("offers_rate_idx").on(table.rate),
     pgCore.index("offers_assets_idx").on(table.assets),
+    pgCore.index("offers_created_at_idx").on(table.createdAt),
     // Compound indices for cursor pagination with hash
     pgCore.index("offers_rate_hash_idx").on(table.rate, table.hash),
     pgCore.index("offers_maturity_hash_idx").on(table.maturity, table.hash),
     pgCore.index("offers_expiry_hash_idx").on(table.expiry, table.hash),
-    pgCore.index("offers_assets_hash_idx").on(table.assets, table.hash)
+    pgCore.index("offers_assets_hash_idx").on(table.assets, table.hash),
+    // Compound index for multi-level sorting optimization (rate, createdAt, assets, hash)
+    pgCore.index("offers_rate_created_at_assets_hash_idx").on(
+      table.rate,
+      drizzleOrm.asc(table.createdAt),
+      drizzleOrm.desc(table.assets),
+      drizzleOrm.asc(table.hash)
+    )
   ]
 );
 var offerCollaterals = s.table(
@@ -1642,6 +1855,7 @@ var availableLiquidityQueues = s.table(
     queueId: pgCore.varchar("queue_id", { length: 255 }).notNull(),
     availableLiquidityPoolId: pgCore.varchar("available_liquidity_pool_id", { length: 255 }).notNull().references(() => availableLiquidityPools.id, { onDelete: "cascade" }),
     index: pgCore.integer("index").notNull(),
+    callbackAmount: pgCore.numeric("callback_amount", { precision: 78, scale: 0 }).default("0").notNull(),
     updatedAt: pgCore.timestamp("updated_at").defaultNow().notNull()
   },
   (table) => [
@@ -1786,6 +2000,7 @@ var create2 = (config) => {
             queueId: qp.queue.queueId,
             availableLiquidityPoolId: qp.pool.id,
             index: qp.queue.index,
+            callbackAmount: qp.queue.callbackAmount,
             updatedAt: /* @__PURE__ */ new Date()
           }).onConflictDoUpdate({
             target: [
@@ -1794,6 +2009,7 @@ var create2 = (config) => {
             ],
             set: {
               index: qp.queue.index,
+              callbackAmount: qp.queue.callbackAmount,
               updatedAt: /* @__PURE__ */ new Date()
             }
           });
@@ -1872,6 +2088,7 @@ function memory2() {
           queueId: qid,
           availableLiquidityPoolId: qp.pool.id,
           index: qp.queue.index,
+          callbackAmount: qp.queue.callbackAmount,
           updatedAt: /* @__PURE__ */ new Date()
         });
         if (!queueIndexByQueueId.has(qid)) queueIndexByQueueId.set(qid, /* @__PURE__ */ new Set());
@@ -2385,7 +2602,8 @@ function create3(config) {
           signature: offers.signature,
           callbackId: offers.callbackId,
           status: latestStatus.status,
-          metadata: latestStatus.metadata
+          metadata: latestStatus.metadata,
+          createdAt: offers.createdAt
         }
       ).from(offers).leftJoinLateral(latestStatus, drizzleOrm.sql`true`).leftJoinLateral(sumConsumed, drizzleOrm.sql`true`).where(
         drizzleOrm.and(
@@ -2440,6 +2658,7 @@ function create3(config) {
         callbackId: bestOffers.callbackId,
         status: bestOffers.status,
         metadata: bestOffers.metadata,
+        createdAt: bestOffers.createdAt,
         // liquidity caps
         userAmount: drizzleOrm.sql`COALESCE(${queueLiquidity.userAmount}, 0)`.as("user_amount"),
         queueLiquidity: drizzleOrm.sql`COALESCE(${queueLiquidity.queueLiquidity}, 0)`.as(
@@ -2449,7 +2668,7 @@ function create3(config) {
         cumulativeRemaining: drizzleOrm.sql`
             SUM(${bestOffers.remaining}) OVER (
               PARTITION BY ${bestOffers.callbackId}
-              ORDER BY ${sortExpr}, ${drizzleOrm.asc(bestOffers.hash)}
+              ORDER BY ${sortExpr}, ${drizzleOrm.asc(bestOffers.createdAt)}, ${bestOffers.assets} DESC, ${drizzleOrm.asc(bestOffers.hash)}
               ROWS UNBOUNDED PRECEDING
             )
           `.as("cumulative_remaining"),
@@ -2459,7 +2678,7 @@ function create3(config) {
               WHEN ${bestOffers.remaining} <= 0 THEN false
               ELSE ( SUM(${bestOffers.remaining}) OVER (
                       PARTITION BY ${bestOffers.callbackId}
-                      ORDER BY ${sortExpr}, ${drizzleOrm.asc(bestOffers.hash)}
+                      ORDER BY ${sortExpr}, ${drizzleOrm.asc(bestOffers.createdAt)}, ${bestOffers.assets} DESC, ${drizzleOrm.asc(bestOffers.hash)}
                       ROWS UNBOUNDED PRECEDING
                     )
                     <= LEAST(
@@ -2493,6 +2712,7 @@ function create3(config) {
         callbackId: offersWithEligibility.callbackId,
         status: offersWithEligibility.status,
         metadata: offersWithEligibility.metadata,
+        createdAt: offersWithEligibility.createdAt,
         userAmount: offersWithEligibility.userAmount,
         queueLiquidity: offersWithEligibility.queueLiquidity,
         cumulativeRemaining: offersWithEligibility.cumulativeRemaining,
@@ -2502,6 +2722,8 @@ function create3(config) {
       ROW_NUMBER() OVER (
         ORDER BY
         CASE WHEN ${offersWithEligibility.buy} THEN ${offersWithEligibility.rate} ELSE -${offersWithEligibility.rate} END,
+        ${offersWithEligibility.createdAt},
+        ${offersWithEligibility.assets} DESC,
         ${drizzleOrm.asc(offersWithEligibility.hash)}
       )
     `.as("row_number")
@@ -2543,6 +2765,10 @@ function create3(config) {
         )
       ).orderBy(
         rateSortDirection === "asc" ? drizzleOrm.asc(validOffers.rate) : drizzleOrm.desc(validOffers.rate),
+        drizzleOrm.asc(validOffers.createdAt),
+        // earlier createdAt first
+        drizzleOrm.desc(validOffers.assets),
+        // higher assets first
         drizzleOrm.asc(validOffers.hash)
       );
       const buildOffersMap = (rows, skipHash) => {