Lend from a Morpho Blue position

import { keccak256, toHex } from "viem";
import { base } from "viem/chains";
import {
  getMidnightBlueBuyCallbackAddress,
  getMidnightBlueBuyCallbackData,
} from "@morpho-org/morpho-sdk";
import { fetchBlueMarketParams } from "@morpho-org/morpho-sdk/fetch";
import type { BlueMarketId } from "@morpho-org/morpho-sdk/types";

// The Morpho Blue market that holds the assets while the offer waits.
const blueMarketId = "0xBlueMarketId..." as BlueMarketId;
const blueMarket = await fetchBlueMarketParams(blueMarketId, client);

// Any bytes32 value. Store it: you need it to find the callback again.
const callbackSalt = keccak256(toHex("my-lend-offer-1"));

// The callback address is computed locally. The contract may not exist yet.
const callback = getMidnightBlueBuyCallbackAddress({
  chainId: base.id,
  owner: maker,
  salt: callbackSalt,
});

// Tells the callback which Morpho Blue market to withdraw from.
const callbackData = getMidnightBlueBuyCallbackData(blueMarket);

import { parseUnits, zeroAddress } from "viem";
import { addresses } from "@morpho-org/morpho-sdk/addresses";
import { Offer } from "@morpho-org/morpho-sdk/midnight/entities";

const marketData = await midnight.getMarketData(marketId);

// Offer expiry: now + 7 days, capped at the market's maturity.
const offerExpiry = BigInt(
  Math.min(Number(marketData.params.maturity), Math.floor(Date.now() / 1000) + 604_800),
);

const lendOffer = Offer.create({
  market: marketData.params,
  maker,
  buy: true,
  tick: 5_000n,
  maxAssets: parseUnits("250000", 6),
  expiry: offerExpiry,
  ratifier: addresses[base.id].priceRatifierV1!,
  callback,
  callbackData,
});

import { maxUint256, parseUnits } from "viem";

const supplyBlueMakeLend = await midnight.supplyBlueMakeLend({
  accountAddress: maker,
  offers: {
    type: "priceV1",
    entries: [{ offer: lendOffer, allowedTaker: zeroAddress }],
  },
  blueMarket,
  assetsToPark: parseUnits("250000", 6), // loan tokens supplied to Morpho Blue for the callback
  callbackSalt,
  deadline: maxUint256,
});

// A loan-token approval to MidnightBundlesV2 and the MidnightBundlesV2 authorization, when missing.
for (const requirement of await supplyBlueMakeLend.getRequirements()) {
  const hash = await client.sendTransaction(requirement);
  await client.waitForTransactionReceipt({ hash });
}
const publishHash = await client.sendTransaction(supplyBlueMakeLend.buildTx());
const publishReceipt = await client.waitForTransactionReceipt({ hash: publishHash });
if (publishReceipt.status !== "success") throw new Error("Publication failed");

import { Group } from "@morpho-org/morpho-sdk/midnight/entities";

const [marketA, marketB] = await Promise.all([
  midnight.getMarketData(marketIdA),
  midnight.getMarketData(marketIdB),
]);

// Every offer must expire at or before its own market's maturity, so cap at the earliest one.
const multiMarketExpiry = BigInt(
  Math.min(
    Number(marketA.params.maturity),
    Number(marketB.params.maturity),
    Math.floor(Date.now() / 1000) + 604_800,
  ),
);

// A separate salt gives this group its own callback and assets, apart from the first example.
const multiMarketSalt = keccak256(toHex("my-multi-market-offer-1"));
const multiMarketCallback = getMidnightBlueBuyCallbackAddress({
  chainId: base.id,
  owner: maker,
  salt: multiMarketSalt,
});

const commonOffer = {
  maker,
  buy: true,
  maxAssets: parseUnits("250000", 6), // one budget for both markets
  expiry: multiMarketExpiry,
  ratifier: addresses[base.id].priceRatifierV1!,
  callback: multiMarketCallback,
  callbackData,
} as const;

const group = Group.create([
  Offer.create({ ...commonOffer, market: marketA.params, tick: 5_000n }),
  Offer.create({ ...commonOffer, market: marketB.params, tick: 5_012n }),
]);

const multiMarket = await midnight.supplyBlueMakeLend({
  accountAddress: maker,
  offers: {
    type: "priceV1",
    entries: group.offers.map((offer) => ({ offer, allowedTaker: zeroAddress })),
  },
  blueMarket,
  assetsToPark: parseUnits("250000", 6),
  callbackSalt: multiMarketSalt,
  deadline: maxUint256,
});

import { maxUint128, maxUint256 } from "viem";
import { blueAbi } from "@morpho-org/morpho-sdk/abis";
import { getChainAddress } from "@morpho-org/morpho-sdk/addresses";

// 1. Cancel the offer groups returned when they were published.
const cancelOffers = midnight.cancelOffers({
  accountAddress: maker,
  cancellations: supplyBlueMakeLend.groups.map((group) => ({ group, maxConsumed: maxUint128 })),
  deadline: maxUint256,
});
for (const requirement of await cancelOffers.getRequirements()) {
  const hash = await client.sendTransaction(requirement);
  await client.waitForTransactionReceipt({ hash });
}
const cancelHash = await client.sendTransaction(cancelOffers.buildTx());
const cancelReceipt = await client.waitForTransactionReceipt({ hash: cancelHash });
// Withdraw only once the cancellation has landed, so no take can use the assets in between.
if (cancelReceipt.status !== "success") throw new Error("Cancellation failed");

// 2. Withdraw all of the callback's supply shares to your wallet.
const blue = getChainAddress(base.id, "blue");
const [supplyShares] = await client.readContract({
  address: blue,
  abi: blueAbi,
  functionName: "position",
  args: [blueMarketId, callback],
});

// Morpho Blue reverts a withdrawal of zero shares, so skip an empty position.
if (supplyShares > 0n) {
  await client.writeContract({
    address: blue,
    abi: blueAbi,
    functionName: "withdraw",
    args: [blueMarket, 0n, supplyShares, callback, maker], // assets, shares, onBehalf, receiver
  });
}

GET https://api.morpho.org/v0/midnight/users/{maker}/offer-groups
  ?chain_ids=8453
  &statuses=expired
  &callback_type=blue_buy

import type { Address } from "viem";

type BlueBuyCallbackInfo = {
  callback_address: string;
  market_id: string;
  market_params: {
    loan_token: string;
    collateral_token: string;
    oracle_address: string;
    irm_address: string;
    lltv_wad: string;
  };
};

const withdrawArgs = ({ callback_address, market_id, market_params }: BlueBuyCallbackInfo) => {
  return {
    callback: callback_address as Address,
    blueMarketId: market_id as BlueMarketId,
    blueMarket: {
      loanToken: market_params.loan_token as Address,
      collateralToken: market_params.collateral_token as Address,
      oracle: market_params.oracle_address as Address,
      irm: market_params.irm_address as Address,
      lltv: BigInt(market_params.lltv_wad),
    },
  };
};