@morpho-org/midnight-sdk 0.1.0 → 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Morpho Association
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -19,8 +19,9 @@ Midnight HTTP API helpers are exported from `@morpho-org/midnight-sdk/api`. This
 ## Making offers
 
 The make-side starts with local offer construction, groups offers that should share consumption, and
-commits grouped and standalone offers into one tree. Validate the tree before asking the maker or an
-authorized signer to sign, or before asking the maker contract to approve the root. Then encode the
+commits grouped and standalone offers into one tree. Ratification inputs are optional for validation,
+so validate the tree before asking the maker or an authorized signer to sign. After signing, pass
+ratification inputs only when you also want to validate the final payload shape. Then encode the
 ratified items into a mempool payload and submit the raw payload bytes onchain.
 
 ```ts
@@ -43,6 +44,7 @@ import {
 const chainId = 8453;
 const usdc = addresses[chainId].usdc!;
 const weth = addresses[chainId].wNative!;
+const midnight = addresses[chainId].midnight!;
 const ecrecoverRatifier = addresses[chainId].ecrecoverRatifier!;
 const midnightMempool = addresses[chainId].midnightMempool!;
 
@@ -52,12 +54,14 @@ export async function makeBaseUsdcWethOffers(params: {
   readonly wethUsdcOracle: Address;
 }) {
   const market = {
+    chainId,
+    midnight,
     loanToken: usdc,
     collateralParams: [
       {
         token: weth,
         lltv: 770_000000000000000000n,
-        maxLif: 1_061007957559681697n,
+        liquidationCursor: 250_000000000000000000n,
         oracle: params.wethUsdcOracle,
       },
     ],
@@ -100,20 +104,30 @@ export async function makeBaseUsdcWethOffers(params: {
     standaloneBorrowOffer,
   ]);
 
-  const treeValidation = await tree.mempoolValidate({
+  // Ratification data is optional here. Omitting it catches API policy issues before asking the maker to sign.
+  await tree.mempoolValidate({
     chainId,
   });
-  if (!treeValidation.valid) {
-    return { ok: false as const, issues: treeValidation.issues };
-  }
 
   // EcrecoverRatifierUtils derives the verifier from offer.ratifier and rejects mixed-ratifier trees.
   // The account may be the maker or an authorized signer for every maker in the tree.
-  const items = await EcrecoverRatifierUtils.ratify({
+  const signature = await EcrecoverRatifierUtils.sign({
     tree,
     client: params.walletClient,
     account: params.maker,
   });
+
+  // Optional final-payload validation: include ratification data when validating post-signature bytes.
+  await tree.mempoolValidate({
+    chainId,
+    ratification: { type: "ecrecover", account: params.maker, signature },
+  });
+
+  const items = await EcrecoverRatifierUtils.ratify({
+    tree,
+    account: params.maker,
+    signature,
+  });
   const payload = await Payload.encode(items);
 
   const transactionHash = await params.walletClient.sendTransaction({
@@ -136,13 +150,8 @@ The take-side starts from API book, quote, or maker takeable-offer responses. `M
 router response into ABI-ready take objects: each item has `offer`, `ratifierData`, and `units` for
 `IMidnight.take`, plus `marketId` metadata from the API. Book `asks` are maker sell offers, while
 book `bids` are maker buy offers.
-For a quote that spans several offers, use `MidnightBundles`: it receives the returned take objects,
-calls `take` internally in order, and fills toward the target in one transaction.
-When executing offers one-by-one with `Midnight.take`, clamp each take to the remaining target instead
-of submitting every returned cap blindly.
-The no-permit bundle example assumes the taker has authorized `MidnightBundles` on Midnight and has
-approved the bundle contract to pull the market loan token. Set `minUnits` or `maxUnits` from your
-own price guard; the example uses `0n` to focus on the route mechanics.
+For a quote that spans several offers, execute the returned takes in order with `Midnight.take` and
+clamp each take to the remaining target instead of submitting every returned cap blindly.
 
 ```ts
 import { addresses } from "@morpho-org/morpho-ts";
@@ -150,10 +159,7 @@ import {
   MidnightApi,
   type MidnightApiTake,
 } from "@morpho-org/midnight-sdk/api";
-import {
-  midnightAbi,
-  midnightBundlesAbi,
-} from "@morpho-org/midnight-sdk";
+import { midnightAbi } from "@morpho-org/midnight-sdk";
 import {
   parseUnits,
   zeroAddress,
@@ -164,14 +170,12 @@ import {
 
 const chainId = 8453;
 const midnight = addresses[chainId].midnight!;
-const midnightBundles = addresses[chainId].midnightBundles!;
-const tokenPermitNone = { kind: 0, data: "0x" } as const;
 
-async function buildAskQuoteTakes(marketId: Hash, targetBuyerAssets: bigint) {
+async function buildAskQuoteTakes(marketId: Hash, targetUnits: bigint) {
   const quote = await MidnightApi.fetchBookQuote({
     marketId,
     side: "asks",
-    assets: targetBuyerAssets,
+    units: targetUnits,
     slippage: "0.5",
   });
 
@@ -201,32 +205,35 @@ export async function takeOneOffer(params: {
   });
 }
 
-export async function takeAskQuoteWithBundle(params: {
+export async function takeAskQuoteSequentially(params: {
   readonly walletClient: WalletClient;
   readonly taker: Address;
+  readonly receiverIfTakerIsSeller: Address;
   readonly marketId: Hash;
 }) {
-  const targetBuyerAssets = parseUnits("10000", 6);
-  const minUnits = 0n;
-  const quote = await buildAskQuoteTakes(params.marketId, targetBuyerAssets);
+  const targetUnits = parseUnits("50", 18);
+  const quote = await buildAskQuoteTakes(params.marketId, targetUnits);
+  const transactionHashes: Hash[] = [];
+  let remainingUnits = targetUnits;
+
+  for (const take of quote.takeableOffers) {
+    if (remainingUnits === 0n) break;
+
+    const units = take.units < remainingUnits ? take.units : remainingUnits;
+    if (units === 0n) continue;
+
+    transactionHashes.push(
+      await takeOneOffer({
+        walletClient: params.walletClient,
+        taker: params.taker,
+        receiverIfTakerIsSeller: params.receiverIfTakerIsSeller,
+        take: { ...take, units },
+      }),
+    );
+    remainingUnits -= units;
+  }
 
-  return params.walletClient.writeContract({
-    account: params.taker,
-    address: midnightBundles,
-    abi: midnightBundlesAbi,
-    functionName: "buyWithAssetsTargetAndWithdrawCollateral",
-    args: [
-      targetBuyerAssets,
-      minUnits,
-      params.taker,
-      tokenPermitNone,
-      quote.takeableOffers,
-      [],
-      params.taker,
-      0n,
-      zeroAddress,
-    ],
-  });
+  return { remainingUnits, transactionHashes };
 }
 ```
 
@@ -239,8 +246,11 @@ normalization. Caller inputs and successful JSON output shapes are trusted at ru
 TypeScript types model the API contract.
 
 Use `tree.mempoolValidate({ chainId })` in normal make-side flows before the maker signs or approves
-the root. Pass `apiUrl` to that method when using a custom Midnight API URL. `MidnightApi` keeps the
-raw HTTP surface, including `validateMempoolPayload` for already encoded payload bytes.
+the root. Ratification data is optional for validation; pass `ratification` only when validating
+final payload bytes with real ratifier data after the signature or Setter proof is available. It
+throws `MidnightMempoolValidationError` with the API issues when policy validation fails. Pass
+`apiUrl` to that method when using a custom Midnight API URL. `MidnightApi` keeps the raw HTTP
+surface, including non-throwing `validateMempoolPayload` results for already encoded payload bytes.
 
 ## Development