Morpho

https://docs.morpho.org/
Admin
Morpho is a decentralized lending protocol enabling overcollateralized lending and borrowing of...
Tokens:656,147
Snippets:3,566
Trust Score:9.8
Update:1 day ago
Show doc for...
Tokens:
Raw
### Install Morpho SDK and viem

Source: https://docs.morpho.org/developers/sdks/morpho-sdk/midnight/

Install the Morpho SDK version 5.8.0 and viem version 2.x using pnpm. This is required for all Midnight examples on this page.

```bash
pnpm add @morpho-org/morpho-sdk@5.8.0 viem@^2.0.0
```

--------------------------------

### GET /v0/midnight/books/{market-id}/asks/quote with response excerpt

Source: https://docs.morpho.org/developers/midnight/concepts/mempool-router/

Example query to the quote endpoint for lending 10,000 USDC and taking asks, with a response excerpt showing takeable offers. The response includes fields like average_best_price, average_worst_price, available_assets, available_units, and takeable_offers with Offer structs and ratifierData. The example uses assets=10000000000 and slippage=0.5.

```http
GET /v0/midnight/books/{market-id}/asks/quote
  ?assets=10000000000
  &slippage=0.5

// Response excerpt (other fields omitted; values are illustrative)
{
  "data": {
    "average_best_price": "998890800000000000",
    "average_worst_price": "1003885254000000000",
    "available_assets": "14983800",
    "available_units": "15000000",
    "takeable_offers": [
      {
        "market_id": "0xa249f0b3ffe8891c96ec93fd9c7d00e479da04e4ffe2f2502ea0e5db8eabc75d",
        "units": "833333",
        "offer": {
          "buy": false,
          "maker": "0x6ba008e3f6ec55dc6412e459ac67949c6d1620c5",
          "max_units": "833333",
          "max_assets": "0",
          "tick": 4736,
          "start": 1782484425,
          "expiry": 1783090799,
          "group": "0x6c544af73868898482d1802005d87e7a4d1100d4e1a6e099a978f6bd2e6cba17",
          "ratifier": "0x1db7b555ce19e85e625428b0e1047da3198211ea"
        },
        "ratifier_data": "0x0000000000000000000000000000000000000000...",
        "valid_until": 1783090799,
        "warning": null
      },
      // more offers
      {...}
    ]
  }
}
```

--------------------------------

### getRequirements Flow - Canonical End-to-End Example

Source: https://docs.morpho.org/developers/sdks/morpho-sdk/

Demonstrates the full flow: get requirements, dispatch them (sign or send transactions), build the final transaction, and send it.

```APIDOC
## getRequirements Flow - Canonical End-to-End Example

### Description
This example shows the canonical end-to-end flow for any vault, market, or Midnight taker action. It resolves on-chain prerequisites, dispatches them (signing signable requirements and sending transactions for others), builds the final transaction, and sends it.

### Code Example
```typescript
import { parseUnits, publicActions } from "viem";
import {
  isRequirementSignature,
  type RequirementSignature,
} from "@morpho-org/morpho-sdk";

// `client` is the extended wallet client from Setup; viem's `publicActions`
// adds `waitForTransactionReceipt` / `getBlock` for the requirement flow.
const publicClient = client.extend(publicActions);

const vaultData = await vaultV2.getData();

const deposit = vaultV2.deposit({
  amount: parseUnits("1", 18), // the vault asset has 18 decimals here
  userAddress: USER_ADDRESS,
  vaultData,
});

// 1. Resolve the on-chain pre-requisites.
const requirements = await deposit.getRequirements();

// 2. Dispatch every requirement: sign the signable ones (off-chain), send the
//    rest as transactions (on-chain) and wait for inclusion.
const signatures: RequirementSignature[] = [];

for (const requirement of requirements) {
  if (isRequirementSignature(requirement)) {
    // Permit / Permit2 / Morpho authorization signature request. `sign` runs
    // the EIP-712 signing flow and enforces builder = signer: it throws
    // `AddressMismatchError` unless the client's connected account equals
    // `USER_ADDRESS` (or `MissingClientPropertyError` when none is connected).
    signatures.push(await requirement.sign(client, USER_ADDRESS));
  } else {
    // ERC-20 approval or Morpho `setAuthorization` transaction. It must be
    // mined before the final transaction can execute.
    const hash = await client.sendTransaction(requirement);
    await publicClient.waitForTransactionReceipt({ hash });
  }
}

// 3. Build the final transaction, passing the collected signatures.
const tx = deposit.buildTx(signatures);
// `tx` is a deep-frozen `{ to, value, data, action }`.

// 4. Send it with the SAME client that built it.
await client.sendTransaction(tx);
```

### Notes
- `isRequirementSignature` splits off-chain signature requests from on-chain transactions.
- The same dispatch loop works for every vault, market, and Midnight taker action.
- Midnight maker flows are the exception: they submit signed offers to the Midnight mempool instead of returning a `viem` `Transaction`.
```

--------------------------------

### GET /v0/midnight/markets/{market-id} response excerpt

Source: https://docs.morpho.org/developers/midnight/concepts/collateral-health-liquidations/

Example response from the endpoint to view each collateral's configuration, showing token, lltv, liquidation_cursor, and oracle fields.

```plaintext
GET /v0/midnight/markets/{market-id}

// Response excerpt (other fields omitted; values are illustrative)
"collaterals": [
  {
    "token":   "0x4200...0006",         // WETH
    "lltv":    "860000000000000000",    // 86% — high LLTV, considered lower risk
    "liquidation_cursor": "250000000000000000",
    "oracle":  "0x1234...abcd"          // price feed for this collateral
  },
  {
    "token":   "0xcbBT...1234",         // cbBTC
    "lltv":    "770000000000000000",    // 77% — lower LLTV, considered higher risk
    "liquidation_cursor": "340000000000000000",
    "oracle":  "0x5678...ef01"
  }
]
```

--------------------------------

### Installation

Source: https://docs.morpho.org/developers/sdks/morpho-sdk/midnight/

Install the Morpho SDK and viem to use the Midnight surface.

```APIDOC
## Installation

### Description
Install the Morpho SDK and viem to use the Midnight surface.

### Command
```
pnpm add @morpho-org/morpho-sdk@5.8.0 viem@^2.0.0
```

### Notes
- Examples that import primitives directly from `@morpho-org/midnight-sdk` or `@morpho-org/morpho-ts` need those packages declared in your own `dependencies` as well - both ship with the Morpho SDK.
```

--------------------------------

### cURL request to get market

Source: https://docs.morpho.org/api/markets/get-market/

Sends a GET request to the market endpoint with a market selector. The example uses a placeholder URL and a sample market selector.

```bash
curl -X GET "https://example.com/v0/blue/markets/1:0xfff1970c0ffae288764186fbb38a9171a17e98676744a1e345809cb8b9e73342"
```

--------------------------------

### Install Morpho SDK and viem

Source: https://docs.morpho.org/developers/borrow/tutorials/assets-flow/

Install the required packages: @morpho-org/morpho-sdk@6.0.0 and viem@^2.0.0. Use npm, pnpm, or yarn.

```bash
npm install @morpho-org/morpho-sdk@6.0.0 viem@^2.0.0
# or
pnpm add @morpho-org/morpho-sdk@6.0.0 viem@^2.0.0
# or
yarn add @morpho-org/morpho-sdk@6.0.0 viem@^2.0.0
```

--------------------------------

### cURL request to get V2 vault realized average APY

Source: https://docs.morpho.org/api/vaults-v2/get-v2-vault-realized-average-apy/

Sends a GET request to the endpoint with a vault selector example. The lookback parameter is optional and defaults to 'six_hours'.

```bash
curl -X GET "https://example.com/v1/vaults-v2/1:0x23f5E9c35820f4baB695Ac1F19c203cC3f8e1e11/apy-averages"
```

--------------------------------

### cURL request to get a book

Source: https://docs.morpho.org/api/midnight/books/get-book/

Sends a GET request to the Midnight books endpoint with a market-id and depth parameter. The example uses a placeholder URL and a sample market ID.

```bash
curl -X GET "https://example.com/v0/midnight/books/0xcc9418ea594c6e658650aedd205ce4544b266b69493f56fd2adc65c14bd06738?depth=100"
```

--------------------------------

### Set up viem client with Morpho extension

Source: https://docs.morpho.org/developers/borrow/tutorials/assets-flow/

Create a wallet client with the Morpho extension and define a market using MarketParams. Requires PRIVATE_KEY and RPC_URL_MAINNET environment variables.

```typescript
import { createWalletClient, http, parseUnits } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { mainnet } from "viem/chains";
import { morphoViemExtension } from "@morpho-org/morpho-sdk";
import { MarketParams } from "@morpho-org/morpho-sdk/entities";

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);

const client = createWalletClient({
  account,
  chain: mainnet,
  transport: http(process.env.RPC_URL_MAINNET),
}).extend(morphoViemExtension({ supportSignature: true }));

const market = client.morpho.blue(
  new MarketParams({
    loanToken: "0xLoanToken...",
    collateralToken: "0xCollateralToken...",
    oracle: "0xOracle...",
    irm: "0xIrm...",
    lltv: 860000000000000000n, // 86%
  }),
  mainnet.id,
);
```

--------------------------------

### Install @morpho-org/morpho-sdk and viem

Source: https://docs.morpho.org/developers/sdks/get-started/

Install the Morpho SDK and viem using pnpm. This is the recommended package for application integrators.

```bash
pnpm add @morpho-org/morpho-sdk viem
```

--------------------------------

### Merkl API endpoint and curl example for user rewards

Source: https://docs.morpho.org/developers/rewards/tutorials/fetch-rewards-data/

Shows the Merkl API endpoint to get a user's claimable rewards and a curl command example. The endpoint is GET https://api.merkl.xyz/v4/users/{address}/rewards?chainId={chainId}. The response is an array of per-chain objects with a rewards array; claimable balance is amount - claimed.

```http
GET https://api.merkl.xyz/v4/users/{address}/rewards?chainId={chainId}
```

```bash
curl "https://api.merkl.xyz/v4/users/0x1234...5678/rewards?chainId=1"
```

--------------------------------

### cURL request to get market state history

Source: https://docs.morpho.org/api/markets/get-market-state-history/

Sends a GET request to the market state history endpoint with a market-selector path parameter. The example uses a placeholder URL and market selector.

```bash
curl -X GET "https://example.com/v0/blue/markets/1:0xfff1970c0ffae288764186fbb38a9171a17e98676744a1e345809cb8b9e73342/state/history"
```

--------------------------------

### Setup - Build Base Client

Source: https://docs.morpho.org/developers/sdks/morpho-sdk/midnight/

Create a Base wallet client extended with morphoViemExtension and publicActions, then obtain the MorphoMidnight entity.

```APIDOC
## Setup - Build Base Client

### Description
Build a Base wallet client (chain id 8453) extended with `morphoViemExtension()` and viem `publicActions`, then call `client.morpho.midnight(base.id)` to get a `MorphoMidnight` entity.

### Code Example
```typescript
import "dotenv/config";
import { type Address, createWalletClient, http, publicActions } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";
import { morphoViemExtension } from "@morpho-org/morpho-sdk";

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);

// Midnight lives on Base, so build the client on `base` (chain id 8453) - not a
// mainnet client. `publicActions` adds the `getBlock` and
// `waitForTransactionReceipt` reads the accrual and requirement flows use.
const client = createWalletClient({
  account,
  chain: base,
  transport: http(process.env.BASE_RPC_URL),
})
  .extend(morphoViemExtension())
  .extend(publicActions);

// Every entity is chain-validated against the client. Reuse `midnight` across
// all Midnight flows below.
const midnight = client.morpho.midnight(base.id);

const user: Address = account.address;
const marketId = "0xMidnightMarketId..." as `0x${string}`;
```
```

--------------------------------

### cURL request to get market state

Source: https://docs.morpho.org/api/markets/get-market-state/

Sends a GET request to the market state endpoint with a market selector formatted as <chain_id>:<market_id>. The example uses a placeholder URL and a sample market ID.

```curl
curl -X GET "https://example.com/v0/blue/markets/1:0xfff1970c0ffae288764186fbb38a9171a17e98676744a1e345809cb8b9e73342/state"
```

--------------------------------

### TypeScript/Viem: Create Mainnet Client and Fetch Market Data

Source: https://docs.morpho.org/developers/borrow/tutorials/get-data/

This TypeScript example sets up a Viem public client for Ethereum mainnet, reads the RPC URL from .env, and defines ABIs for Morpho Blue, interest rate model, and ERC20 tokens. It demonstrates fetching market state and emphasizes that the market() view function does not include interest accrued since the last onchain interaction; use the SDK or manual calculation for up-to-date values.

```typescript
import "dotenv/config";
import {
  createPublicClient,
  http,
  formatUnits,
  PublicClient,
  parseAbi,
  Address,
} from "viem";
import { mainnet } from "viem/chains";

/**
 * Creates and configures a Viem Public Client for the Ethereum mainnet.
 * It reads the RPC URL from the .env file.
 * @returns A configured Viem public client.
 */
export function createMainnetClient(): PublicClient {
  const rpcUrl = process.env.RPC_URL_MAINNET;
  if (!rpcUrl) {
    throw new Error(
      "RPC_URL_MAINNET is not set in the .env file. Please add it."
    );
  }

  return createPublicClient({
    chain: mainnet,
    transport: http(rpcUrl, {
      retryCount: 2,
      batch: {
        batchSize: 100,
        wait: 200,
      },
    }),
    batch: {
      multicall: {
        batchSize: 2048,
        wait: 100,
      },
    },
  });
}

// Morpho V1 contract address
const MORPHO_BLUE_ADDRESS: Address = "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb";

// Example market ID for demonstration
const EXAMPLE_MARKET_ID: `0x${string}` = "0x64d65c9a2d91c36d56fbc42d69e979335320169b3df63bf92789e2c8883fcc64";

// Morpho V1 ABI for market operations
const MORPHO_BLUE_ABI = parseAbi([
  "function market(bytes32 id) view returns (uint128 totalSupplyAssets, uint128 totalSupplyShares, uint128 totalBorrowAssets, uint128 totalBorrowShares, uint128 lastUpdate, uint128 fee)",
  "function idToMarketParams(bytes32 id) view returns (address loanToken, address collateralToken, address oracle, address irm, uint256 lltv)",
  "function position(bytes32 id, address user) view returns (uint256 supplyShares, uint128 borrowShares, uint128 collateral)",
]);

// Interest Rate Model ABI
const IRM_ABI = parseAbi([
  "function borrowRateView((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, (uint128 totalSupplyAssets, uint128 totalSupplyShares, uint128 totalBorrowAssets, uint128 totalBorrowShares, uint128 lastUpdate, uint128 fee) market) view returns (uint256)",
]);

// ERC20 ABI for token information
const ERC20_ABI = parseAbi([
  "function symbol() view returns (string)",
  "function name() view returns (string)",
  "function decimals() view returns (uint8)",
  "function totalSupply() view returns (uint256)",
]);

type MarketParams = {
  readonly loanToken: Address;
  readonly collateralToken: Address;
  readonly oracle: Address;
  readonly irm: Address;
  readonly lltv: bigint;
};

type MarketState = {
  readonly totalSupplyAssets: bigint;
  readonly totalSupplyShares: bigint;
  readonly totalBorrowAssets: bigint;
  readonly totalBorrowShares: bigint;
  readonly lastUpdate: bigint;
  readonly fee: bigint;
};

interface TokenInfo {
  address: Address;
  symbol: string;
  name: string;
  decimals: number;
}
```

--------------------------------

### Define market and create offers with Offer.create

Source: https://docs.morpho.org/developers/sdks/morpho-sdk/midnight/

Shows how to define a market and create lend and borrow offers using Offer.create. Requires importing addresses from @morpho-org/morpho-ts, Offer from @morpho-org/midnight-sdk, and viem utilities. The market description is copied verbatim from a live Base market; onchain reads address the market by its id hash. Omitted fields get protocol defaults: start defaults to zero, continuousFeeCap to protocol maximum, callback/callbackData to none, and receiverIfMakerIsSeller to the maker on sell offers. Exactly one of maxUnits or maxAssets must be non-zero.

```typescript
import { addresses } from "@morpho-org/morpho-ts";
import { Offer } from "@morpho-org/midnight-sdk";
import { parseUnits, zeroAddress, type Address } from "viem";

const chainId = 8453;
const usdc = addresses[chainId].usdc!;
const cbBtc = "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf" as Address;   // cbBTC on Base
const midnightAddress = addresses[chainId].midnight!;
const ecrecoverRatifier = addresses[chainId].ecrecoverRatifier!;

const maker = "0xMaker00000000000000000000000000000000000" as Address;
const usdcOracle = "0x4429112b3C00b40Cf295db81cfcdE39d7d5ADC1d" as Address;    // from the live market's collateralParams
const cbBtcOracle = "0x663BECd10daE6C4A3Dcd89F1d76c1174199639B9" as Address;   // from the live market's collateralParams

// Immutable market description, copied verbatim from a live Base market
// (0xf5564b5322b8...3fc5, GET /v0/midnight/markets?chain_id=8453) so its
// maturity is in the future. Onchain reads address the market by its id hash.
const market = {
  chainId,
  midnight: midnightAddress,
  loanToken: usdc,
  collateralParams: [
    {
      token: usdc,
      lltv: 980_000_000_000_000_000n,
      liquidationCursor: 300_000_000_000_000_000n,
      oracle: usdcOracle,
    },
    {
      token: cbBtc,
      lltv: 860_000_000_000_000_000n,
      liquidationCursor: 300_000_000_000_000_000n,
      oracle: cbBtcOracle,
    },
  ],
  maturity: 1_806_073_200n, // 2027-03-26 15:00:00 UTC.
  rcfThreshold: 3_000000000n,
  enterGate: zeroAddress,
  liquidatorGate: zeroAddress,
};

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

const commonOffer = {
  market,
  maker,
  expiry: offerExpiry,
  ratifier: ecrecoverRatifier,
};

// Maker buys units = lends. `maxAssets` caps consumption in loan-token terms.
const lend250kUsdc = Offer.create({
  ...commonOffer,
  buy: true,
  tick: 5_000n,
  maxAssets: parseUnits("250000", 6),
});

// Maker sells units = borrows. `maxUnits` caps consumption in units.
const borrow50Units = Offer.create({
  ...commonOffer,
  buy: false,
  tick: 5_024n,
  maxUnits: parseUnits("50", 18),
});
```

--------------------------------

### cURL request to get user market position performance

Source: https://docs.morpho.org/api/markets/user-market-position-performance/

Sends a GET request to the performance endpoint using the example market selector and user address. Requires an API key for enterprise access.

```bash
curl -X GET "https://example.com/v0/blue/markets/1:0xfff1970c0ffae288764186fbb38a9171a17e98676744a1e345809cb8b9e73342/users/0xabcdefabcdefabcdefabcdefabcdefabcdefabcd/position/performance"
```

--------------------------------

### cURL request to get token price

Source: https://docs.morpho.org/api/global/get-token-price/

Sends a GET request to the token price endpoint using a token selector in the format <chain_id>:<address>. The example uses chain ID 8453 and a specific address.

```cURL
curl -X GET "https://example.com/v0/tokens/8453:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913/price"
```

--------------------------------

### Viem client setup and ERC20 asset data retrieval

Source: https://docs.morpho.org/developers/borrow/tutorials/get-data/

TypeScript example using Viem to create a mainnet public client and fetch comprehensive ERC20 asset information including metadata, balances, and allowances. Requires RPC_URL_MAINNET in .env.

```typescript
import "dotenv/config";
import {
  createPublicClient,
  http,
  formatUnits,
  PublicClient,
  parseAbi,
  Address,
} from "viem";
import { mainnet } from "viem/chains";

/**
 * Creates and configures a Viem Public Client for the Ethereum mainnet.
 * It reads the RPC URL from the .env file.
 * @returns A configured Viem public client.
 */
export function createMainnetClient(): PublicClient {
  const rpcUrl = process.env.RPC_URL_MAINNET;
  if (!rpcUrl) {
    throw new Error(
      "RPC_URL_MAINNET is not set in the .env file. Please add it."
    );
  }

  return createPublicClient({
    chain: mainnet,
    transport: http(rpcUrl, {
      retryCount: 2,
      batch: {
        batchSize: 100,
        wait: 200,
      },
    }),
    batch: {
      multicall: {
        batchSize: 2048,
        wait: 100,
      },
    },
  });
}

// Example token addresses for demonstration
const EXAMPLE_ASSETS: Address[] = [
  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
  "0xdAC17F958D2ee523a2206206994597C13D831ec7", // USDT
  "0x6B175474E89094C44Da98b954EedeAC495271d0F", // DAI
  "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", // WBTC
];

// Comprehensive ERC20 ABI for asset information
const ERC20_ABI = parseAbi([
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function decimals() view returns (uint8)",
  "function totalSupply() view returns (uint256)",
  "function balanceOf(address account) view returns (uint256)",
  "function allowance(address owner, address spender) view returns (uint256)",
]);
```

--------------------------------

### cURL request to get user market position

Source: https://docs.morpho.org/api/markets/user-market-position/

Sends a GET request to the user market position endpoint. Requires the user-address and market-selector path parameters. The example uses a placeholder base URL 'https://example.com'.

```bash
curl -X GET "https://example.com/v0/blue/markets/1:0x15bb2a6af0c909eed19fb1f2ceeead34ecbdcba626de752c6b09389ee14eec32/users/0x0774b5B15B0CEe5E2e14814CCF4d4611fF78CcF5/position"
```

--------------------------------

### 200 response body for GET /v0/chains

Source: https://docs.morpho.org/api/chains/get-chains/

Example JSON response with a data array containing chain_id, name, last_indexed_block, and supported_protocols.

```json
{  "data": [    {      "chain_id": 1,      "name": "string",      "last_indexed_block": "string",      "supported_protocols": [        "blue"      ]    }  ]}
```

--------------------------------

### Setup: Extend viem client with morphoViemExtension

Source: https://docs.morpho.org/developers/sdks/morpho-sdk/

Imports the SDK and viem, creates a wallet client from a private key, and extends it with morphoViemExtension. The extension enables signature support, deployless multicall, and metadata. The builder signer invariant is enforced via validateUserAddress, throwing MissingClientPropertyError or AddressMismatchError.

```TypeScript
import "dotenv/config";
import { type Address, createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { mainnet } from "viem/chains";
import { morphoViemExtension } from "@morpho-org/morpho-sdk";

// Private-key account: this is the connected account the SDK enforces as the signer.
const account = privateKeyToAccount(process.env.PRIVATE_KEY as Address);

// This is the account the builders must be told about (see the invariant below).
const USER_ADDRESS = account.address;

// Extend a viem wallet client with the Morpho namespace. `client.morpho` exposes
// four stateless entity factories: `vaultV1`, `vaultV2`, `blue`, and `midnight`.
const client = createWalletClient({
  account,
  chain: mainnet,
  transport: http(process.env.RPC_URL),
}).extend(
  morphoViemExtension({
    // Collect EIP-712 permit / permit2 signatures instead of only on-chain ERC-20
    // approvals; defaults to `false` (classic approvals only).
    supportSignature: true,
    // Analytics metadata stamped onto every transaction the namespace builds.
    // `timestamp` is optional; `origin` is required when `metadata` is passed.
    // `origin` is hexadecimal calldata (at most 8 hex chars / 4 bytes, even
    // length, optional 0x prefix), NOT a clear-text name - an invalid origin
    // is dropped with only a console warning.
    metadata: { origin: "0xbeef01", timestamp: true },
    // Allow entity fetchers to use deployless multicall for on-chain reads.
    supportDeployless: true,
  }),
);

// Builder = signer invariant:
// The `userAddress` you pass to any builder MUST equal the account connected to THIS
// extended client, and the SAME client MUST sign and send the resulting transaction.
// Signature requirements enforce it when `sign(client, userAddress)` is called, via
// `validateUserAddress` - throwing `MissingClientPropertyError` when the client has
// no connected account, or `AddressMismatchError` when the connected account does
// not match `userAddress`. Transaction builders do not re-validate at build time.
```

--------------------------------

### Read accrued position via onchain contract read

Source: https://docs.morpho.org/developers/midnight/tutorials/redeem-lend-at-maturity/

Use this direct contract read to get the live, accrued values needed to size a redemption. It reads updatePositionView to get newCredit and newPendingFee, and withdrawable to get the liquidity bound. The example uses the Midnight contract address on Base and the midnightAbi from the Morpho SDK.

```TypeScript
import { createPublicClient, http } from "viem";
import { base } from "viem/chains";
import { midnightAbi } from "@morpho-org/morpho-sdk/abis";

const MIDNIGHT = "0xAdedD8ab6dE832766Fedf0FaC4992E5C4D3EA18A";   // Midnight on Base (from the @morpho-org/morpho-ts address registry)

const publicClient = createPublicClient({ chain: base, transport: http() });

// market = the Market struct - from GET /v0/midnight/markets/{marketId} or a prior browse step

// A full redemption uses the accrued redeemable credit - the same value the
// SDK redeems by default (positionData.faceValue): newCredit minus the accrued
// pending fee.
const [newCredit, newPendingFee] = await publicClient.readContract({
  address: MIDNIGHT,
  abi: midnightAbi,
  functionName: "updatePositionView",
  args: [market, marketId, lender],
});

// The market's withdrawable liquidity in units - the bound Midnight.withdraw
// enforces (the same value the SDK's redeem flow checks).
const withdrawable = await publicClient.readContract({
  address: MIDNIGHT,
  abi: midnightAbi,
  functionName: "withdrawable",
  args: [marketId],
});
const units =
  newCredit - newPendingFee < withdrawable ? newCredit - newPendingFee : withdrawable;
if (units === 0n) throw new Error("no withdrawable liquidity yet, retry later");
```

--------------------------------

### List all user positions (GET /v0/midnight/users/{user-address}/positions)

Source: https://docs.morpho.org/developers/api/morpho-midnight/

Returns all positions for a user across markets. Includes cost_basis and effective_rate_wad inline. Position types: lend, borrow, collateral_only. The response shows a lend position with fields like chain_id, market_id, loan_token, maturity, credit, pending_fee, debt, cost_basis, effective_rate_wad, effective_apr, collaterals, created_at, and type.

```bash
curl "https://api.morpho.org/v0/midnight/users/0xAlice.../positions"

// Response:
{
  "cursor": null,
  "data": [
    {
      "chain_id": 8453,
      "market_id": "0xd92d...7614",
      "user_address": "0xAlice...",
          "loan_token": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "maturity": 1798761600,
      "credit": "10500000000",
      "pending_fee": "12000",
      "last_loss_factor": "0",
      "loss_factor": "0",
      "debt": "0",
      "cost_basis": "952380952380952380",
      "effective_rate_wad": "52000000000000000",
      "effective_apr": 0.0508,
      "collaterals": [],
      "created_at": 1761922790,
      "type": "lend"
    }
  ]
}
```

--------------------------------

### Install both Morpho skills with npx

Source: https://docs.morpho.org/developers/agents/skills/

Installs both earn-integration and borrow-integration skills on an Agent Skills-compatible host.

```bash
npx skills add morpho-org/morpho-skills
```

--------------------------------

### Get quote by units with curl

Source: https://docs.morpho.org/developers/api/morpho-midnight/

Quotes by units instead of assets. This example requests a quote for 10,500,000,000 units on the asks side.

```bash
curl "https://api.morpho.org/v0/midnight/books/0xd92d...7614/asks/quote\
  ?units=10500000000"
```

--------------------------------

### 200 response body for get market

Source: https://docs.morpho.org/api/markets/get-market/

Example JSON response returned with a 200 status code, showing the market configuration fields.

```json
{  "data": {    "chain_id": 1,    "market_id": "string",    "loan_token": "string",    "collateral_token": "string",    "oracle_address": "string",    "irm_address": "string",    "lltv_wad": "string",    "creation_block_number": "string"  }}
```

--------------------------------

### Install individual Morpho skills with npx

Source: https://docs.morpho.org/developers/agents/skills/

Installs either the earn-integration or borrow-integration skill individually.

```bash
npx skills add morpho-org/morpho-skills --skill earn-integration
npx skills add morpho-org/morpho-skills --skill borrow-integration
```

--------------------------------

### 400 error response for get book

Source: https://docs.morpho.org/api/midnight/books/get-book/

Example error response for a validation failure, including error code, message, details, and request ID.

```json
{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Limit must be greater than 0.",
    "details": [
      {
        "field": "limit",
        "issue": "Limit must be greater than 0."
      }
    ],
    "request_id": "req-123"
  }
}
```
Tokens:
Raw