@morpho-org/consumer-sdk 0.4.0 → 0.5.0

package/README.md

@@ -8,16 +8,19 @@
 
 ## Entities & Actions
 
-| Entity      | Action          | Route                     | Why                                                                                     |
-| ----------- | --------------- | ------------------------- | --------------------------------------------------------------------------------------- |
-| **VaultV2** | `deposit`       | Bundler (general adapter) | Enforces `maxSharePrice` — inflation attack prevention. Supports native token wrapping. |
-|             | `withdraw`      | Direct vault call         | No attack surface, no bundler overhead needed                                           |
-|             | `redeem`        | Direct vault call         | No attack surface, no bundler overhead needed                                           |
-|             | `forceWithdraw` | Vault `multicall`         | N `forceDeallocate` + 1 `withdraw` in a single tx                                       |
-|             | `forceRedeem`   | Vault `multicall`         | N `forceDeallocate` + 1 `redeem` in a single tx                                         |
-| **VaultV1** | `deposit`       | Bundler (general adapter) | Same ERC-4626 inflation attack prevention as V2. Supports native token wrapping.        |
-|             | `withdraw`      | Direct vault call         | No attack surface                                                                       |
-|             | `redeem`        | Direct vault call         | No attack surface                                                                       |
+| Entity       | Action                   | Route                     | Why                                                                                                 |
+| ------------ | ------------------------ | ------------------------- | --------------------------------------------------------------------------------------------------- |
+| **VaultV2**  | `deposit`                | Bundler (general adapter) | Enforces `maxSharePrice` — inflation attack prevention. Supports native token wrapping.             |
+|              | `withdraw`               | Direct vault call         | No attack surface, no bundler overhead needed                                                       |
+|              | `redeem`                 | Direct vault call         | No attack surface, no bundler overhead needed                                                       |
+|              | `forceWithdraw`          | Vault `multicall`         | N `forceDeallocate` + 1 `withdraw` in a single tx                                                   |
+|              | `forceRedeem`            | Vault `multicall`         | N `forceDeallocate` + 1 `redeem` in a single tx                                                     |
+| **VaultV1**  | `deposit`                | Bundler (general adapter) | Same ERC-4626 inflation attack prevention as V2. Supports native token wrapping.                    |
+|              | `withdraw`               | Direct vault call         | No attack surface                                                                                   |
+|              | `redeem`                 | Direct vault call         | No attack surface                                                                                   |
+| **MarketV1** | `supplyCollateral`       | Bundler (general adapter) | `erc20TransferFrom` + `morphoSupplyCollateral`. Supports native wrapping.                           |
+|              | `borrow`                 | Bundler (general adapter) | `morphoBorrow` with `minSharePrice` slippage protection. Requires GA1 auth. Supports reallocations. |
+|              | `supplyCollateralBorrow` | Bundler (general adapter) | Atomic supply + borrow. LLTV buffer prevents instant liquidation. Supports reallocations.           |
 
 ## VaultV2
 
@@ -151,6 +154,111 @@ const { buildTx } = vault.redeem({
 const tx = buildTx();
 ```
 
+## MarketV1
+
+```typescript
+const market = morpho.marketV1(
+  {
+    loanToken: "0xLoan...",
+    collateralToken: "0xCollateral...",
+    oracle: "0xOracle...",
+    irm: "0xIrm...",
+    lltv: 860000000000000000n,
+  },
+  1
+);
+```
+
+### Supply Collateral
+
+```typescript
+const { buildTx, getRequirements } = market.supplyCollateral({
+  amount: 1000000000000000000n,
+  userAddress: "0xUser...",
+});
+
+const requirements = await getRequirements();
+const tx = buildTx(requirementSignature);
+```
+
+### Borrow
+
+```typescript
+const positionData = await market.getPositionData("0xUser...");
+
+const { buildTx, getRequirements } = market.borrow({
+  amount: 500000000000000000n,
+  userAddress: "0xUser...",
+  positionData,
+});
+
+const requirements = await getRequirements();
+const tx = buildTx();
+```
+
+### Supply Collateral & Borrow
+
+```typescript
+const positionData = await market.getPositionData("0xUser...");
+
+const { buildTx, getRequirements } = market.supplyCollateralBorrow({
+  amount: 1000000000000000000n,
+  borrowAmount: 500000000000000000n,
+  userAddress: "0xUser...",
+  positionData,
+});
+
+const requirements = await getRequirements();
+const tx = buildTx(requirementSignature);
+```
+
+### Borrow with Shared Liquidity (Reallocations)
+
+When a market lacks sufficient liquidity, you can reallocate liquidity from other markets managed by MetaMorpho Vaults via the **PublicAllocator** contract:
+
+```typescript
+import type { VaultReallocation } from "@morpho-org/consumer-sdk";
+
+const reallocations: VaultReallocation[] = [
+  {
+    vault: "0xVault...", // MetaMorpho vault to reallocate from
+    fee: 0n, // PublicAllocator fee in native token (can be 0)
+    withdrawals: [
+      {
+        marketParams: sourceMarketParams, // Source market to withdraw from
+        amount: 2000000000n, // Amount to withdraw
+      },
+    ],
+  },
+];
+
+const positionData = await market.getPositionData("0xUser...");
+
+// Borrow with reallocations
+const { buildTx, getRequirements } = market.borrow({
+  amount: 500000000000000000n,
+  userAddress: "0xUser...",
+  positionData,
+  reallocations,
+});
+
+const requirements = await getRequirements();
+const tx = buildTx();
+// tx.value includes the sum of all reallocation fees
+```
+
+Reallocations also work with `supplyCollateralBorrow`:
+
+```typescript
+const { buildTx, getRequirements } = market.supplyCollateralBorrow({
+  amount: 1000000000000000000n,
+  borrowAmount: 500000000000000000n,
+  userAddress: "0xUser...",
+  positionData,
+  reallocations,
+});
+```
+
 ## Architecture
 
 ```mermaid
@@ -159,6 +267,7 @@ graph LR
 
     MC -->|.vaultV1| MV1
     MC -->|.vaultV2| MV2
+    MC -->|.marketV1| MM1
 
     subgraph VaultV1 Flow
         MV1[MorphoVaultV1]
@@ -186,18 +295,35 @@ graph LR
         V2FR -->|multicall| V2C
     end
 
+    subgraph MarketV1 Flow
+        MM1[MorphoMarketV1]
+        MM1 --> M1SC[marketV1SupplyCollateral]
+        MM1 --> M1B[marketV1Borrow]
+        MM1 --> M1SCB[marketV1SupplyCollateralBorrow]
+
+        M1SC -->|erc20TransferFrom + morphoSupplyCollateral| B3[Bundler3]
+        M1B -->|reallocateTo? + morphoBorrow| B3
+        M1SCB -->|transfer + supplyCollateral + reallocateTo? + borrow| B3
+
+        B3 -.->|reallocateTo| PA[PublicAllocator]
+    end
+
+
     subgraph Shared
         REQ[getRequirements]
     end
 
     MV1 -.->|approval / permit| REQ
     MV2 -.->|approval / permit| REQ
+    MM1 -.->|approval / permit / authorization| REQ
 
     style B1 fill:#e8f5e9,stroke:#4caf50
     style B2 fill:#e8f5e9,stroke:#4caf50
+    style B3 fill:#e8f5e9,stroke:#4caf50
     style MM fill:#fff3e0,stroke:#ff9800
     style V2C fill:#e3f2fd,stroke:#2196f3
     style REQ fill:#f3e5f5,stroke:#9c27b0
+    style PA fill:#fff9c4,stroke:#f9a825
 ```
 
 ## Local Development

package/lib/actions/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./marketV1";
 export * from "./requirements";
 export * from "./vaultV1";
 export * from "./vaultV2";

package/lib/actions/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./marketV1"), exports);
 __exportStar(require("./requirements"), exports);
 __exportStar(require("./vaultV1"), exports);
 __exportStar(require("./vaultV2"), exports);

package/lib/actions/marketV1/borrow.d.ts

@@ -0,0 +1,34 @@
+import type { MarketParams } from "@morpho-org/blue-sdk";
+import type { Address } from "viem";
+import { type MarketV1BorrowAction, type Metadata, type Transaction, type VaultReallocation } from "../../types";
+/** Parameters for {@link marketV1Borrow}. */
+export interface MarketV1BorrowParams {
+    market: {
+        readonly chainId: number;
+        readonly marketParams: MarketParams;
+    };
+    args: {
+        amount: bigint;
+        receiver: Address;
+        /** Minimum borrow share price (in ray). Protects against share price manipulation. */
+        minSharePrice: bigint;
+        /** Vault reallocations to execute before borrowing (computed by entity). */
+        reallocations?: readonly VaultReallocation[];
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a borrow transaction for a Morpho Blue market.
+ *
+ * Routed through bundler3 via `morphoBorrow`. The bundler uses the transaction
+ * initiator as `onBehalf`. Uses `minSharePrice` to protect against share price
+ * manipulation between transaction construction and execution.
+ *
+ * When `reallocations` are provided, `reallocateTo` actions are prepended to
+ * the bundle, moving liquidity from other markets via the PublicAllocator
+ * before borrowing. The reallocation fees are set as the transaction value.
+ *
+ * @param params - Borrow parameters.
+ * @returns Deep-frozen transaction.
+ */
+export declare const marketV1Borrow: ({ market: { chainId, marketParams }, args: { amount, receiver, minSharePrice, reallocations }, metadata, }: MarketV1BorrowParams) => Readonly<Transaction<MarketV1BorrowAction>>;

package/lib/actions/marketV1/borrow.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketV1Borrow = void 0;
+const bundler_sdk_viem_1 = require("@morpho-org/bundler-sdk-viem");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const helpers_1 = require("../../helpers");
+const types_1 = require("../../types");
+const buildReallocationActions_1 = require("./buildReallocationActions");
+/**
+ * Prepares a borrow transaction for a Morpho Blue market.
+ *
+ * Routed through bundler3 via `morphoBorrow`. The bundler uses the transaction
+ * initiator as `onBehalf`. Uses `minSharePrice` to protect against share price
+ * manipulation between transaction construction and execution.
+ *
+ * When `reallocations` are provided, `reallocateTo` actions are prepended to
+ * the bundle, moving liquidity from other markets via the PublicAllocator
+ * before borrowing. The reallocation fees are set as the transaction value.
+ *
+ * @param params - Borrow parameters.
+ * @returns Deep-frozen transaction.
+ */
+const marketV1Borrow = ({ market: { chainId, marketParams }, args: { amount, receiver, minSharePrice, reallocations }, metadata, }) => {
+    if (amount <= 0n) {
+        throw new types_1.NonPositiveBorrowAmountError(marketParams.id);
+    }
+    if (minSharePrice < 0n) {
+        throw new types_1.NonPositiveMinBorrowSharePriceError(marketParams.id);
+    }
+    const actions = [];
+    let reallocationFee = 0n;
+    if (reallocations && reallocations.length > 0) {
+        const result = (0, buildReallocationActions_1.buildReallocationActions)(reallocations, marketParams);
+        actions.push(...result.actions);
+        reallocationFee = result.fee;
+    }
+    actions.push({
+        type: "morphoBorrow",
+        args: [marketParams, amount, 0n, minSharePrice, receiver, false],
+    });
+    let tx = {
+        ...bundler_sdk_viem_1.BundlerAction.encodeBundle(chainId, actions),
+        value: reallocationFee,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "marketV1Borrow",
+            args: {
+                market: marketParams.id,
+                amount,
+                receiver,
+                minSharePrice,
+                reallocationFee,
+            },
+        },
+    });
+};
+exports.marketV1Borrow = marketV1Borrow;

package/lib/actions/marketV1/buildReallocationActions.d.ts

@@ -0,0 +1,17 @@
+import type { MarketParams } from "@morpho-org/blue-sdk";
+import type { Action } from "@morpho-org/bundler-sdk-viem";
+import type { VaultReallocation } from "../../types";
+/**
+ * Builds reallocation bundler actions and computes the total fee.
+ *
+ * Validates the reallocations, then encodes each as a `reallocateTo` action.
+ * Caller must ensure `reallocations` is non-empty before calling.
+ *
+ * @param reallocations - The vault reallocations to encode.
+ * @param targetMarketParams - The target market params for the borrow.
+ * @returns The encoded actions and total reallocation fee.
+ */
+export declare const buildReallocationActions: (reallocations: readonly VaultReallocation[], targetMarketParams: MarketParams) => {
+    readonly actions: Action[];
+    readonly fee: bigint;
+};

package/lib/actions/marketV1/buildReallocationActions.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildReallocationActions = void 0;
+const helpers_1 = require("../../helpers");
+/**
+ * Builds reallocation bundler actions and computes the total fee.
+ *
+ * Validates the reallocations, then encodes each as a `reallocateTo` action.
+ * Caller must ensure `reallocations` is non-empty before calling.
+ *
+ * @param reallocations - The vault reallocations to encode.
+ * @param targetMarketParams - The target market params for the borrow.
+ * @returns The encoded actions and total reallocation fee.
+ */
+const buildReallocationActions = (reallocations, targetMarketParams) => {
+    (0, helpers_1.validateReallocations)(reallocations, targetMarketParams.id);
+    const fee = reallocations.reduce((sum, r) => sum + r.fee, 0n);
+    const actions = [];
+    for (const r of reallocations) {
+        actions.push({
+            type: "reallocateTo",
+            args: [
+                r.vault,
+                r.fee,
+                r.withdrawals.map((w) => ({
+                    marketParams: w.marketParams,
+                    amount: w.amount,
+                })),
+                targetMarketParams,
+                false,
+            ],
+        });
+    }
+    return { actions, fee };
+};
+exports.buildReallocationActions = buildReallocationActions;

package/lib/actions/marketV1/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./borrow";
+export * from "./repay";
+export * from "./repayWithdrawCollateral";
+export * from "./supplyCollateral";
+export * from "./supplyCollateralBorrow";
+export * from "./withdrawCollateral";

package/lib/actions/marketV1/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./borrow"), exports);
+__exportStar(require("./repay"), exports);
+__exportStar(require("./repayWithdrawCollateral"), exports);
+__exportStar(require("./supplyCollateral"), exports);
+__exportStar(require("./supplyCollateralBorrow"), exports);
+__exportStar(require("./withdrawCollateral"), exports);

package/lib/actions/marketV1/repay.d.ts

@@ -0,0 +1,44 @@
+import { type MarketParams } from "@morpho-org/blue-sdk";
+import { type Address } from "viem";
+import type { MarketV1RepayAction, Metadata, RequirementSignature, Transaction } from "../../types";
+/** Parameters for {@link marketV1Repay}. */
+export interface MarketV1RepayParams {
+    market: {
+        readonly chainId: number;
+        readonly marketParams: MarketParams;
+    };
+    args: {
+        /** Repay assets amount (0n when repaying by shares). */
+        assets: bigint;
+        /** Repay shares amount (0n when repaying by assets). */
+        shares: bigint;
+        /** ERC20 amount to transfer to GeneralAdapter1. Must be greater than or equal to the repay amount to take into account the slippage. */
+        transferAmount: bigint;
+        /** Address whose debt is being repaid. */
+        onBehalf: Address;
+        /** Receives residual loan tokens in shares mode. */
+        receiver: Address;
+        /** Maximum repay share price (in ray). Protects against share price manipulation. */
+        maxSharePrice: bigint;
+        requirementSignature?: RequirementSignature;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a repay transaction for a Morpho Blue market.
+ *
+ * Routed through bundler3 via GeneralAdapter1. Supports two modes:
+ * - **By assets** (`assets > 0, shares = 0`): repays an exact asset amount.
+ * - **By shares** (`assets = 0, shares > 0`): repays exact shares (full repay).
+ *
+ * Exactly one of `assets`/`shares` must be non-zero. The `transferAmount` controls
+ * how many ERC20 tokens are pulled from the user (may differ from `assets` in
+ * shares mode where the entity computes an upper-bound estimate).
+ *
+ * Uses `maxSharePrice` to protect against share price manipulation between
+ * transaction construction and execution.
+ *
+ * @param params - Repay parameters.
+ * @returns Deep-frozen transaction.
+ */
+export declare const marketV1Repay: ({ market: { chainId, marketParams }, args: { assets, shares, transferAmount, onBehalf, receiver, maxSharePrice, requirementSignature, }, metadata, }: MarketV1RepayParams) => Readonly<Transaction<MarketV1RepayAction>>;

package/lib/actions/marketV1/repay.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketV1Repay = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const bundler_sdk_viem_1 = require("@morpho-org/bundler-sdk-viem");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
+const helpers_1 = require("../../helpers");
+const getRequirementsAction_1 = require("../requirements/getRequirementsAction");
+/**
+ * Prepares a repay transaction for a Morpho Blue market.
+ *
+ * Routed through bundler3 via GeneralAdapter1. Supports two modes:
+ * - **By assets** (`assets > 0, shares = 0`): repays an exact asset amount.
+ * - **By shares** (`assets = 0, shares > 0`): repays exact shares (full repay).
+ *
+ * Exactly one of `assets`/`shares` must be non-zero. The `transferAmount` controls
+ * how many ERC20 tokens are pulled from the user (may differ from `assets` in
+ * shares mode where the entity computes an upper-bound estimate).
+ *
+ * Uses `maxSharePrice` to protect against share price manipulation between
+ * transaction construction and execution.
+ *
+ * @param params - Repay parameters.
+ * @returns Deep-frozen transaction.
+ */
+const marketV1Repay = ({ market: { chainId, marketParams }, args: { assets, shares, transferAmount, onBehalf, receiver, maxSharePrice, requirementSignature, }, metadata, }) => {
+    (0, helpers_1.validateRepayParams)({
+        assets,
+        shares,
+        transferAmount,
+        maxSharePrice,
+        marketId: marketParams.id,
+    });
+    const { bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    const actions = [];
+    if (requirementSignature) {
+        actions.push(...(0, getRequirementsAction_1.getRequirementsAction)({
+            chainId,
+            asset: marketParams.loanToken,
+            amount: transferAmount,
+            requirementSignature,
+        }));
+    }
+    else {
+        actions.push({
+            type: "erc20TransferFrom",
+            args: [marketParams.loanToken, transferAmount, generalAdapter1, false],
+        });
+    }
+    actions.push({
+        type: "morphoRepay",
+        args: [marketParams, assets, shares, maxSharePrice, onBehalf, [], false],
+    });
+    // Skim residual loan tokens back to the payer when repaying by shares.
+    // In shares mode, transferAmount is an upper-bound estimate; morphoRepay
+    // consumes only the exact amount needed, leaving a residual in the adapter.
+    if (shares > 0n) {
+        actions.push({
+            type: "erc20Transfer",
+            args: [
+                marketParams.loanToken,
+                receiver,
+                viem_1.maxUint256,
+                generalAdapter1,
+                false,
+            ],
+        });
+    }
+    let tx = {
+        ...bundler_sdk_viem_1.BundlerAction.encodeBundle(chainId, actions),
+        value: 0n,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "marketV1Repay",
+            args: {
+                market: marketParams.id,
+                assets,
+                shares,
+                transferAmount,
+                onBehalf,
+                receiver,
+                maxSharePrice,
+            },
+        },
+    });
+};
+exports.marketV1Repay = marketV1Repay;

package/lib/actions/marketV1/repayWithdrawCollateral.d.ts

@@ -0,0 +1,51 @@
+import { type MarketParams } from "@morpho-org/blue-sdk";
+import { type Address } from "viem";
+import { type MarketV1RepayWithdrawCollateralAction, type Metadata, type RequirementSignature, type Transaction } from "../../types";
+/** Parameters for {@link marketV1RepayWithdrawCollateral}. */
+export interface MarketV1RepayWithdrawCollateralParams {
+    market: {
+        readonly chainId: number;
+        readonly marketParams: MarketParams;
+    };
+    args: {
+        /** Repay assets amount (0n when repaying by shares). */
+        assets: bigint;
+        /** Repay shares amount (0n when repaying by assets). */
+        shares: bigint;
+        /** ERC20 amount to transfer to GeneralAdapter1 (computed by entity). */
+        transferAmount: bigint;
+        /** Amount of collateral to withdraw. */
+        withdrawAmount: bigint;
+        /** Address whose debt is being repaid. */
+        onBehalf: Address;
+        /** Receives withdrawn collateral and residual loan tokens in shares mode. */
+        receiver: Address;
+        /** Maximum repay share price (in ray). Protects against share price manipulation. */
+        maxSharePrice: bigint;
+        requirementSignature?: RequirementSignature;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares an atomic repay-and-withdraw-collateral transaction for a Morpho Blue market.
+ *
+ * Routed through bundler3. The bundle order is critical:
+ * 1. ERC20 transfer (loan token to GeneralAdapter1)
+ * 2. `morphoRepay` — reduces debt FIRST
+ * 3. `morphoWithdrawCollateral` — then withdraws collateral
+ *
+ * If the order were reversed, Morpho would revert because the position would be
+ * insolvent at the time of the withdraw.
+ *
+ * Supports two repay modes:
+ * - **By assets** (`assets > 0, shares = 0`): repays an exact asset amount.
+ * - **By shares** (`assets = 0, shares > 0`): repays exact shares (full repay).
+ *
+ * **Prerequisites:**
+ * - ERC20 approval for loan token to GeneralAdapter1 (for the repay).
+ * - GeneralAdapter1 must be authorized on Morpho (for the withdraw).
+ *
+ * @param params - Combined repay and withdraw collateral parameters.
+ * @returns Deep-frozen transaction.
+ */
+export declare const marketV1RepayWithdrawCollateral: ({ market: { chainId, marketParams }, args: { assets, shares, transferAmount, withdrawAmount, onBehalf, receiver, maxSharePrice, requirementSignature, }, metadata, }: MarketV1RepayWithdrawCollateralParams) => Readonly<Transaction<MarketV1RepayWithdrawCollateralAction>>;