Custom Deposit for {vaultToken.symbol}
APY: {(apy * 100).toFixed(2)}%
setDepositAmount(e.target.value)} /> {/* TheBorrow USDC with cbBTC Collateral
setCollateralAmount(e.target.value)} disabled={loading} /> setBorrowAmount(e.target.value)} disabled={loading} /> {txHash &&Success! Transaction: {txHash}
} {error &&Error: {error}
}** | Deployed addresses for the `Bundler3` contracts and adapters on all supported networks. | | **Contract Specifications** | **[/get-started/resources/contracts/bundlers/](https://docs.morpho.org/get-started/resources/contracts/bundlers)
** | Detailed specifications for the `Bundler3` contract and its adapters. | | **Bundler SDKs** | **[/tools/offchain/sdks/bundler-sdk-viem/](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem)
** | The recommended SDK for interacting with bundlers in a dApp. | | **GitHub Repository** | **[https://github.com/morpho-org/bundler3](https://github.com/morpho-org/bundler3)
** | The source code for the `Bundler3` smart contracts and adapters. | --- # Using LLMs – Morpho Docs [Skip to content](https://docs.morpho.org/tools/ai/llms/#vocs-content) Search... [](https://docs.morpho.org/) [](https://docs.morpho.org/) Developers Hub Chevron Down Menu Using LLMs On this page Chevron Right Morpho’s docs are LLM-friendly to help developers integrate with Morpho faster. Use the Morpho docs llms-full.txt file You can provide your code editor with a llms-full.txt file to use Morpho's docs as a context for your code. The following steps show how to do this for Cursor. #### Navigate to `Cursor Settings` > `Features` > `Docs`[](https://docs.morpho.org/tools/ai/llms/#navigate-to-cursor-settings--features--docs) #### Select “Add new doc” and paste the following URL:[](https://docs.morpho.org/tools/ai/llms/#select-add-new-doc-and-paste-the-following-url) Copy `https://docs.morpho.org/llms-full.txt` #### Use @docs -> Morpho to reference Morpho's docs in your code.[](https://docs.morpho.org/tools/ai/llms/#use-docs---morpho-to-reference-morphos-docs-in-your-code) --- # Morpho Docs [Skip to content](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#vocs-content) Search... [](https://docs.morpho.org/) [](https://docs.morpho.org/) Developers Hub Chevron Down Menu On this page Chevron Right Introduction[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#introduction) ------------------------------------------------------------------------------------- The [**blue-sdk**](https://github.com/morpho-org/sdks/tree/main/packages/blue-sdk) is the core SDK in the Morpho Stack. It provides the foundational components necessary to interact with Morpho's offchain ecosystem. This SDK is framework-agnostic, making it versatile for various applications. Key features include: * Market configuration management * Market data manipulation * User position management * Token and vault interactions Installation[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#installation) ------------------------------------------------------------------------------------- First, install the necessary dependencies: Copy `yarn add @morpho-org/blue-sdk @morpho-org/morpho-ts` Setup[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#setup) ----------------------------------------------------------------------- Import the necessary modules and set up your environment: Copy `import { MarketParams, Market, AccrualPosition, Position, } from "@morpho-org/blue-sdk"; import { Time } from "@morpho-org/morpho-ts";` Basic Usage[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#basic-usage) ----------------------------------------------------------------------------------- Here's a script that demonstrates the basic usage of the [**blue-sdk**](https://github.com/morpho-org/sdks/tree/main/packages/blue-sdk) : Copy `// Create a new market configuration using MarketParams const config = new MarketParams({ loanToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0", // wstETH oracle: "0x2a01EB9496094dA03c4E364Def50f5aD1280AD72", irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC", // AdaptiveCurveIrm lltv: 94_5000000000000000n, // 94.5% }); console.log("Market Config ID:", config.id); console.log("Liquidation Incentive Factor:", config.liquidationIncentiveFactor); // Create a new market with the specified configuration const market = new Market({ config, totalSupplyAssets: 1000_000000000000000000n, totalBorrowAssets: 920_000000000000000000n, totalSupplyShares: 1000_000000000000000000000000n, totalBorrowShares: 920_000000000000000000000000n, lastUpdate: 1721000000n, fee: 0n, price: 1_100000000000000000000000000000000000n, rateAtTarget: 94850992095n, }); console.log("Market Utilization:", market.utilization); console.log("Market Liquidity:", market.liquidity); console.log("Market APY at Target:", market.apyAtTarget); // Accrue interest to the latest timestamp const accruedMarket = market.accrueInterest(Time.timestamp()); // Convert supply shares to assets const shares = 1000000000000000000n; console.log("Supply Assets for Shares:", accruedMarket.toSupplyAssets(shares)); // Create a new position in the market const position = new AccrualPosition( new Position({ user: "0xCDB238D68d8Da74487711bC1F8f13f3d00667D1A", // Replace with actual user address marketId: market.id, supplyShares: 0n, borrowShares: 20_000000000000000000000000n, collateral: 27_000000000000000000n, }), market ); console.log("Borrow Assets:", position.borrowAssets); console.log("Is Position Healthy:", position.isHealthy); console.log("Max Borrowable Assets:", position.maxBorrowableAssets); // Accrue interest for the position to the latest timestamp const accruedPosition = position.accrueInterest(Time.timestamp()); console.log("Accrued Borrow Assets:", accruedPosition.borrowAssets);` Key Classes[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#key-classes) ----------------------------------------------------------------------------------- ### MarketParams[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#marketparams) Represents the immutable configuration of a market on Morpho. This class replaces the previous `MarketConfig` class and provides: * Market configuration parameters (loan token, collateral token, oracle, IRM, LLTV) * Computed properties like `liquidationIncentiveFactor` * Unique market identifier ### Market[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#market) Represents the state of a market on Morpho, including: * Total supply and borrow amounts * Utilization and liquidity metrics * Interest rate calculations * Share-to-asset conversions ### Position[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#position) Represents a user's position on a specific market, including: * Supply and borrow shares * Collateral amounts * Health factor calculations * Maximum borrowable asset calculations Advanced Usage[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#advanced-usage) ----------------------------------------------------------------------------------------- ### Integrating with Other SDKs[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#integrating-with-other-sdks) * Integrate with [blue-sdk-viem](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/-viem) for onchain interactions. ### Custom Address Registration[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#custom-address-registration) For testing or custom networks, you can register custom addresses: Copy `import { registerCustomAddresses } from "@morpho-org/blue-sdk"; registerCustomAddresses({ addresses: { 31337: { morpho: "0x123...", // ... other required addresses }, }, unwrappedTokens: { 31337: { "0xWrappedToken": "0xUnwrappedToken", }, }, });` ### Error Handling[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#error-handling) Always implement proper error handling and input validation in production code. ### Complex Scenarios[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#complex-scenarios) Explore more complex scenarios such as: * Multi-market interactions * Vault allocations * Token management Conclusion[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#conclusion) --------------------------------------------------------------------------------- This tutorial provides a comprehensive overview of how to use the [**blue-sdk**](https://github.com/morpho-org/sdks/tree/main/packages/blue-sdk) to interact with Morpho markets and positions. For more detailed information, refer to the official Morpho documentation. Full Code Example[](https://docs.morpho.org/tools/offchain/sdks/blue-sdk/#full-code-example) ----------------------------------------------------------------------------------------------- Copy `import { MarketParams, Market, AccrualPosition, Position, } from "@morpho-org/blue-sdk"; import { Time } from "@morpho-org/morpho-ts"; // Create a new market configuration using MarketParams const config = new MarketParams({ loanToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0", // wstETH oracle: "0x2a01EB9496094dA03c4E364Def50f5aD1280AD72", irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC", // AdaptiveCurveIrm lltv: 94_5000000000000000n, // 94.5% }); console.log("Market Config ID:", config.id); console.log("Liquidation Incentive Factor:", config.liquidationIncentiveFactor); // Create a new market with the specified configuration const market = new Market({ params: config, totalSupplyAssets: 1000_000000000000000000n, totalBorrowAssets: 920_000000000000000000n, totalSupplyShares: 1000_000000000000000000000000n, totalBorrowShares: 920_000000000000000000000000n, lastUpdate: 1721000000n, fee: 0n, price: 1_100000000000000000000000000000000000n, rateAtTarget: 94850992095n, }); console.log("Market Utilization:", market.utilization); console.log("Market Liquidity:", market.liquidity); console.log("Market APY at Target:", market.apyAtTarget); // Accrue interest to the latest timestamp const accruedMarket = market.accrueInterest(Time.timestamp()); // Convert supply shares to assets const shares = 1000000000000000000n; console.log("Supply Assets for Shares:", accruedMarket.toSupplyAssets(shares)); // Create a new position in the market const position = new AccrualPosition( new Position({ user: "0xCDB238D68d8Da74487711bC1F8f13f3d00667D1A", // Replace with actual user address marketId: market.id, supplyShares: 0n, borrowShares: 20_000000000000000000000000n, collateral: 27_000000000000000000n, }), market ); console.log("Borrow Assets:", position.borrowAssets); console.log("Is Position Healthy:", position.isHealthy); console.log("Max Borrowable Assets:", position.maxBorrowableAssets); // Accrue interest for the position to the latest timestamp const accruedPosition = position.accrueInterest(Time.timestamp()); console.log("Accrued Borrow Assets:", accruedPosition.borrowAssets);` --- # Morpho Docs [Skip to content](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#vocs-content) Search... [](https://docs.morpho.org/) [](https://docs.morpho.org/) Developers Hub Chevron Down Menu On this page Chevron Right Introduction[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#introduction) --------------------------------------------------------------------------------------------- The [bundler-sdk-viem](https://github.com/morpho-org/sdks/tree/main/packages/bundler-sdk-viem) enables atomic execution of complex DeFi operations on Morpho by bundling multiple actions into a single transaction. This eliminates the need for multiple approvals, reduces gas costs, and prevents intermediate state changes that could affect your position. **Prerequisites**: This guide assumes you have: * Working knowledge of [blue-sdk](https://docs.morpho.org/tools/offchain/sdks/blue-sdk) and [blue-sdk-viem](https://docs.morpho.org/tools/offchain/sdks/blue-sdk-viem) * A configured [Viem client](https://viem.sh/docs/clients/intro) * Understanding of Morpho's market mechanics * Familiarity with TypeScript and async/await patterns **Important**: The bundler SDK requires deep understanding of Morpho's transaction flows. Study the [SDK tests](https://github.com/morpho-org/sdks/tree/main/packages/bundler-sdk-viem/test) and reference implementations before building production features. Architecture Overview[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#architecture-overview) --------------------------------------------------------------------------------------------------------------- The bundler transforms high-level user operations into optimized transaction bundles through three phases: 1. **Population**: Convert user operations into low-level bundler operations 2. **Finalization**: Optimize operations (merge duplicates, redirect tokens, add skims) 3. **Encoding**: Package operations into executable transactions with signature requirements Installation[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#installation) --------------------------------------------------------------------------------------------- Copy `yarn add @morpho-org/bundler-sdk-viem @morpho-org/blue-sdk @morpho-org/morpho-ts @morpho-org/simulation-sdk viem` Core Concepts[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#core-concepts) ----------------------------------------------------------------------------------------------- ### Operation Types[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#operation-types) The bundler supports three categories of operations: #### Blue Operations (No `address` field)[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#blue-operations-no-address-field) * `Blue_Supply` - Supply assets to a market * `Blue_Borrow` - Borrow assets from a market * `Blue_Repay` - Repay borrowed assets * `Blue_Withdraw` - Withdraw supplied assets * `Blue_SupplyCollateral` - Supply collateral * `Blue_WithdrawCollateral` - Withdraw collateral * `Blue_SetAuthorization` - Authorize an address * `Blue_FlashLoan` - Execute a flash loan **Critical**: Blue operations do not have an `address` field. They always operate on the Morpho contract address. #### MetaMorpho Operations (Have `address` field)[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#metamorpho-operations-have-address-field) * `MetaMorpho_Deposit` - Deposit into a vault * `MetaMorpho_Withdraw` - Withdraw from a vault * `MetaMorpho_PublicReallocate` - Trigger public reallocation #### ERC20 Operations (Have `address` field)[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#erc20-operations-have-address-field) * `Erc20_Approve` - Standard approval * `Erc20_Permit` - Gasless approval via signature * `Erc20_Permit2` - Uniswap Permit2 approval * `Erc20_Transfer` - Transfer tokens * `Erc20_Wrap` - Wrap tokens (e.g., ETH → WETH) * `Erc20_Unwrap` - Unwrap tokens (e.g., WETH → ETH) ### Type Guards[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#type-guards) Always use the correct type guards when processing operations: Copy `import { isBlueBundlerOperation, isMetaMorphoBundlerOperation, isErc20BundlerOperation, } from "@morpho-org/bundler-sdk-viem"; operations.forEach((operation) => { if (isBlueBundlerOperation(operation)) { // No address field - operates on Morpho contract if ("id" in operation.args) { const marketParams = MarketParams.get(operation.args.id); } } if (isMetaMorphoBundlerOperation(operation) || isErc20BundlerOperation(operation)) { // Has address field const { address } = operation; } });` ### SimulationState[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#simulationstate) `SimulationState` represents the complete protocol state at a specific block. It's required for: * Simulating operations before execution * Validating transaction feasibility * Calculating required approvals and transfers * Optimizing operation sequences **Getting SimulationState**: Reference production implementations like [compound-blue](https://github.com/papercliplabs/compound-blue/blob/main/src/actions/data/rpc/getSimulationState.ts) to understand proper state fetching patterns. Critical Security Practices[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#critical-security-practices) --------------------------------------------------------------------------------------------------------------------------- ### 1\. Never Approve Bundler 3[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#1-never-approve-bundler-3) **NEVER** set token approvals for Bundler 3 directly. This is a critical security risk. See the [official security notice](https://github.com/morpho-org/bundler3?tab=readme-ov-file#security-notice-on-approvals-to-bundler3) . The bundler SDK handles approvals correctly through Permit/Permit2 flows. ### 2\. Always Skim Residual Tokens[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#2-always-skim-residual-tokens) Every transaction involving tokens must include skim operations to return any residual tokens to the user. Failing to skim can result in: * Lost user funds trapped in adapters/bundler * Transaction surplus not returned to users * Poor user experience Copy `// Always skim both input and output tokens const skimOperations = [ { type: "Erc20_Transfer", sender: user, address: tokenAddress, args: { recipient: user, amount: MaxUint256, // Transfers all remaining balance } } ];` ### 3\. Handle Swap Surplus Correctly[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#3-handle-swap-surplus-correctly) When using DEX integrations (e.g., exact output swaps), you may receive more tokens than expected. Always skim **both**: * The token you sent * The token you received Example from production: Copy `// Skim shares back to user { type: "Erc20_Transfer", args: [vaultAddress, account.address, maxUint256, generalAdapter1, false] }, // Skim asset tokens back to user { type: "Erc20_Transfer", args: [vaultAsset.address, account.address, maxUint256, generalAdapter1, false] }` Key Functions[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#key-functions) ----------------------------------------------------------------------------------------------- ### populateBundle[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#populatebundle) Converts high-level user operations into a bundle of low-level operations by simulating each action. Copy `const { operations, steps } = populateBundle( inputOperations: InputBundlerOperation[], simulationState: SimulationState, bundlingOptions?: BundlingOptions );` **Returns**: * `operations`: Array of bundler operations to execute * `steps`: Simulation steps for debugging ### finalizeBundle[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#finalizebundle) Optimizes the operation bundle by merging duplicates, redirecting tokens, and adding necessary skims. Copy `const optimizedOperations = finalizeBundle( operations: BundlerOperation[], simulationState: SimulationState, receiverAddress: Address, unwrapTokens?: Set, unwrapSlippage?: bigint );` **Key optimizations**: * Merges duplicate ERC20 approvals * Redirects token flows when possible * Adds skim operations for residual tokens * Handles token unwrapping with slippage protection ### encodeBundle[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#encodebundle) Packages optimized operations into an executable transaction with signature requirements. Copy `const bundle = encodeBundle( operations: BundlerOperation[], simulationState: SimulationState, supportsSignature?: boolean );` **Returns**: `ActionBundle` containing: * `tx()`: Function to get the main transaction * `requirements.signatures`: Permits/Permit2s to sign * `requirements.txs`: Prerequisite transactions (if any) Bundling Options[](https://docs.morpho.org/tools/offchain/sdks/bundler-sdk-viem/#bundling-options) ----------------------------------------------------------------------------------------------------- Fine-tune bundler behavior with `BundlingOptions`: Copy `interface BundlingOptions { // Tokens to use simple permit (not Permit2) withSimplePermit?: Set; // Enable public allocator for liquidity reallocation publicAllocatorOptions?: { enabled: boolean; supplyTargetUtilization?: Record
{/* Vault Header */} {/* APY Display */} {/* Rewards List */} {data.rewards.length > 0 && (
); }`
**File: `src/components/UserRewardsPanel.tsx`**
Copy
`export function UserRewardsPanel({ userAddress, chainId }) { const [rewards, setRewards] = useState(null); const [claiming, setClaiming] = useState(false); useEffect(() => { getUserRewards(userAddress, chainId).then(setRewards); }, [userAddress, chainId]); const handleClaimAll = async () => { setClaiming(true); try { // Claim from both systems await Promise.all([ claimMerklRewards(userAddress, chainId, walletClient), claimURDRewards(userAddress, walletClient), ]); alert("Rewards claimed successfully!"); // Refresh rewards data getUserRewards(userAddress, chainId).then(setRewards); } catch (error) { console.error("Claim failed:", error); alert("Claim failed. See console for details."); } finally { setClaiming(false); } }; return ( {data.vault.name}
{data.vault.symbol}
Total APY {data.totalApy.toFixed(2)}%
Base APY: {data.baseApy.toFixed(2)}%
{data.rewardsApr > 0 && ( Rewards: +{data.rewardsApr.toFixed(2)}%
)} Your Claimable Rewards
{rewards?.combined.map((reward) => ( {reward.token} {formatAmount(reward.amount)} {reward.token}
))} {/* Show source breakdown */} View breakdown
Merkl: {rewards?.merkl.length || 0} rewards
URD: {rewards?.urd.length || 0} rewards
** | A practical guide on how to trigger a reallocation, including an Etherscan walkthrough. | | **Contract Addresses** | **[/get-started/resources/addresses/](https://docs.morpho.org/get-started/resources/addresses)
** | Official addresses for the Public Allocator contract on all supported chains. | | **Solidity Specs & Errors** | **[/get-started/resources/contracts/public-allocator/](https://docs.morpho.org/get-started/resources/contracts/public-allocator)
** | Detailed contract specifications, function descriptions, and a table of common error messages. | | **API & Data Endpoints** | **[/tools/offchain/api/](https://docs.morpho.org/tools/offchain/api/get-started)
** | How to query GraphQL for flow caps, fees, and available reallocatable liquidity. | --- # App Integration – Morpho Docs [Skip to content](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#vocs-content) Search... [](https://docs.morpho.org/) [](https://docs.morpho.org/) Developers Hub Chevron Down Menu App Integration On this page Chevron Right This tutorial assumes you are already familiar with Morpho’s core packages (such as [blue-sdk](https://docs.morpho.org/tools/offchain/sdks/blue-sdk) and [blue-sdk-viem](https://docs.morpho.org/tools/offchain/sdks/blue-sdk-viem) ) and have set up a [Viem client](https://viem.sh/docs/clients/intro#introduction-to-clients--transports) for onchain interactions. For working examples, check out the [bundler-basic-app](https://github.com/morpho-org/bundler-basic-app) or the [earn-basic-app](https://github.com/morpho-org/earn-basic-app) repositories. Prerequisites Using SDKs[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#prerequisites-using-sdks) ----------------------------------------------------------------------------------------------------------------------- The [bundler-sdk-viem](https://github.com/morpho-org/sdks/tree/main/packages/bundler-sdk-viem) package extends Morpho’s simulation and interaction capabilities by converting simple user interactions (e.g., supply, borrow, repay, withdraw) into a bundled transaction. This bundle automatically includes all necessary ERC20 approvals, transfers, token wrapping/unwrapping, and even public liquidity reallocations. In short, it enables you to execute complex DeFi operations atomically, thereby reducing gas fees and minimizing the risk of intermediate state changes. The bundler works by: * Simulating the full sequence of operations. * Populating a bundle with required ERC20 operations. * Optimizing the operations (merging duplicates, redirecting tokens when possible). * Encoding the bundle for submission using Viem. ### Installation[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#installation) Install the bundler package along with its required peer dependencies: Copy `yarn add @morpho-org/bundler-sdk-viem @morpho-org/blue-sdk @morpho-org/morpho-ts viem` ### Setup[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#setup) First, import the basic key functions and types from [bundler-sdk-viem](https://github.com/morpho-org/sdks/tree/main/packages/bundler-sdk-viem) as well as from Morpho’s other packages: Copy `import { populateBundle, finalizeBundle, encodeBundle, type BundlingOptions, type InputBundlerOperation, } from "@morpho-org/bundler-sdk-viem"; import { MarketId, DEFAULT_SLIPPAGE_TOLERANCE } from "@morpho-org/blue-sdk"; import { SimulationState } from "@morpho-org/simulation-sdk"; import { WalletClient } from "viem";` Also, set up your [Viem client](https://viem.sh/docs/clients/intro#introduction-to-clients--transports) and [simulation state](https://github.com/morpho-org/sdks/tree/main/packages/simulation-sdk-wagmi#getting-started) as needed for your application. As a reminder, an example has been implemented in this [bundler-basic-app](https://github.com/morpho-org/bundler-basic-app/blob/main/src/hooks/usePopulatedSimulationState.ts) . Core Concepts[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#core-concepts) ------------------------------------------------------------------------------------------------- ### Bundled Operations[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#bundled-operations) The [bundler-sdk-viem](https://github.com/morpho-org/sdks/tree/main/packages/bundler-sdk-viem) transforms input operations—which represent simple user actions—into a bundle of low-level onchain operations. Here is the list of all the input operations: #### Blue Operations:[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#blue-operations) * Blue\_SetAuthorization * Blue\_Borrow * Blue\_Repay * Blue\_Supply * Blue\_SupplyCollateral * Blue\_Withdraw * Blue\_WithdrawCollateral #### Morpho Vaults Operations:[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#morpho-vaults-operations) * MetaMorpho\_Deposit * MetaMorpho\_Withdraw * MetaMorpho\_PublicReallocate For example, when a user wants to 1. Supply assets, 2. Supply collateral, 3. and then borrow in one transaction, you can pass three input operations: * Blue\_Supply * Blue\_SupplyCollateral * Blue\_Borrow The bundler automatically adds: * The required ERC20 approvals (via Erc20\_Approve, Erc20\_Permit, or Erc20\_Permit2) * ERC20 transfers from the user to the bundler * Additional steps such as token wrapping or unwrapping #### Using Slippage Tolerance[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#using-slippage-tolerance) When working with DeFi operations, including slippage tolerance is crucial for transaction success. Slippage occurs because between the time a transaction is simulated and when it's actually mined onchain: * Accrued interest might change the expected output amount * Market states may be updated by other transactions * Vault conditions might shift slightly The `DEFAULT_SLIPPAGE_TOLERANCE` parameter (imported from `@morpho-org/blue-sdk`) covers these minor discrepancies to ensure your transactions succeed even when market conditions change slightly. **Important**: Always include the slippage parameter in operations that involve asset conversions, including: * `Blue_Supply` * `Blue_Borrow` * `Blue_Repay` * `Blue_Withdraw` * `MetaMorpho_Deposit` * `MetaMorpho_Withdraw` #### Assets vs Shares Parameters[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#assets-vs-shares-parameters) Morpho operations often allow you to specify either an `assets` or `shares` parameter, depending on your use case, please read this section about [Assets vs Shares](https://docs.morpho.org/build/borrow/tutorials/assets-flow) Full RepayPartial Vault WithdrawFull Vault Withdraw Full Repay Copy `{ type: "Blue_Repay", sender: userAddress, address: morpho, args: { id: marketId, shares: position.borrowShares, // Full repayment onBehalf: userAddress, slippage: DEFAULT_SLIPPAGE_TOLERANCE, // Always include slippage }, }` ### Key Functions[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#key-functions) #### populateBundle[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#populatebundle) This function is the entry point to convert an array of InputBundlerOperation into a bundle of low-level operations. It: * Simulates each input operation using the current SimulationState. * Returns an object containing the bundled operations along with the simulation steps. Copy `const { operations, steps } = populateBundle( inputOperations, simulationState, bundlingOptions );` #### finalizeBundle[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#finalizebundle) After populating the bundle, finalizeBundle is used to: * Merge duplicate operations (e.g., multiple ERC20 approvals or transfers). * Optimize the operation sequence by redirecting tokens (e.g., from the bundler to the receiver). * Append any additional transfer operations to “skim” any remaining tokens. Copy `const optimizedOperations = finalizeBundle( operations, simulationState, receiverAddress, unwrapTokensSet, unwrapSlippage );` #### encodeBundle[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#encodebundle) Once the operations are optimized, they are encoded into a single transaction using encodeBundle. This function packages all the operations along with the requirements for signatures so that the transaction can be submitted onchain. ### Simulation & Error Handling[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#simulation--error-handling) The [bundler-sdk-viem](https://github.com/morpho-org/sdks/tree/main/packages/bundler-sdk-viem) integrates tightly with [simulation-sdk](https://github.com/morpho-org/sdks/tree/main/packages/simulation-sdk) . Functions such as `simulateRequiredTokenAmounts`, `simulateBundlerOperations`, and `getSimulatedBundlerOperation` are used to: * Simulate the effect of each bundled operation on your current state. * Determine how much of each token is required (especially for ERC20 transfers). * Handle errors by providing detailed simulation steps, which can be very useful during development and testing. Always wrap your bundling logic in a try-catch block to capture and log errors. ### Advanced Bundling Options[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#advanced-bundling-options) You can customize the bundling behavior via the BundlingOptions parameter: Copy `const bundlingOptions: BundlingOptions = { withSimplePermit: new Set(["0xTokenAddress1", "0xTokenAddress2"]), publicAllocatorOptions: { enabled: true, supplyTargetUtilization: { [marketId]: 905000000000000000n, // For a specific market }, defaultSupplyTargetUtilization: 905000000000000000n, }, getRequirementOperations: (requiredTokenAmounts) => { // Optionally, add custom operations to handle token requirements. return []; }, };` These options allow you to: * Force simple permit flows on certain tokens * Trigger liquidity reallocation when the market’s utilization exceeds a target threshold * Inject custom logic to handle required token amounts ### Sending the Transaction[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#sending-the-transaction) Once the bundle is encoded and signed, the transaction is sent to the blockchain via your Viem wallet client. The setupBundle function iterates through the individual transactions (including any signature requirements) and sends them sequentially. Example Implementation[](https://docs.morpho.org/tools/onchain/bundlers/app-integration/#example-implementation) ------------------------------------------------------------------------------------------------------------------- Let's walk through a practical example that demonstrates how to bundle multiple Morpho actions into a single transaction. This example shows how to: 1. Supply assets to a market 2. Supply collateral 3. Borrow assets You can find a complete working implementation in our [bundler-basic-app](https://github.com/morpho-org/bundler-basic-app) repository. Copy `import { type Account, WalletClient, zeroAddress } from "viem"; import { parseAccount } from "viem/accounts"; import { type Address, addresses, ChainId, DEFAULT_SLIPPAGE_TOLERANCE, MarketId, MarketParams, UnknownMarketParamsError, getUnwrappedToken, } from "@morpho-org/blue-sdk"; import { type BundlingOptions, type InputBundlerOperation, encodeBundle, finalizeBundle, populateBundle, } from "@morpho-org/bundler-sdk-viem"; import "@morpho-org/blue-sdk-viem/lib/augment"; import { withSimplePermit } from "@morpho-org/morpho-test"; import { type SimulationState, SimulationState, isBlueOperation, isErc20Operation, isMetaMorphoOperation, } from "@morpho-org/simulation-sdk"; export const setupBundle = async ( client: WalletClient, startData: SimulationState, inputOperations: InputBundlerOperation[], { account: account_ = client.account, supportsSignature, unwrapTokens, unwrapSlippage, onBundleTx, ...options }: BundlingOptions & { account?: Address | Account; supportsSignature?: boolean; unwrapTokens?: Set; unwrapSlippage?: bigint; onBundleTx?: (data: SimulationState) => Promise
\[ \] | newSupplyQueue is an array of enabled markets, and can contain duplicate markets, but it would only increase the cost of depositing to the vault. | ### updateWithdrawQueue[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#updatewithdrawqueue) Copy `function updateWithdrawQueue(uint256[] calldata indexes) external onlyAllocatorRole {};` Updates the withdraw queue. Some markets can be removed, but no market can be added. * Removing a market requires the vault to have 0 supply on it, or to have previously submitted a removal for this market (with the function `submitMarketRemoval`). * Warning: Anyone can supply on behalf of the vault so the call to `updateWithdrawQueue` that expects a market to be empty can be griefed by a front-run. To circumvent this, the allocator can simply bundle a reallocation that withdraws max from this market with a call to `updateWithdrawQueue`. * Warning: Removing a market with supply will decrease the fee accrued until one of the functions updating `lastTotalAssets` is triggered (deposit/mint/withdraw/redeem/setFee/setFeeRecipient). * Warning: `updateWithdrawQueue` is not idempotent. Submitting twice the same tx will change the queue twice. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#parameters-18) | Name | Type | Description | | --- | --- | --- | | `indexes` | uint256 \[ \] | The indexes of each market in the previous withdraw queue, in the new withdraw queue's order. | ### reallocate[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#reallocate) Copy `function reallocate(MarketAllocation[] calldata allocations) external onlyAllocatorRole {};` Reallocates the vault's liquidity so as to reach a given allocation of assets on each given market. * The allocator can withdraw from any market, even if it's not in the withdraw queue, as long as the loan token of the market is the same as the vault's asset. * The behavior of the reallocation can be altered by state changes, including: * Deposits on the vault that supplies to markets that are expected to be supplied to during reallocation. * Withdrawals from the vault that withdraws from markets that are expected to be withdrawn from during reallocation. * Donations to the vault on markets that are expected to be supplied to during reallocation. * Withdrawals from markets that are expected to be withdrawn from during reallocation. * Sender is expected to pass `assets = type(uint256).max` with the last MarketAllocation of `allocations` to supply all the remaining withdrawn liquidity, which would ensure that `totalWithdrawn` = `totalSupplied`. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#parameters-19) | Name | Type | Description | | --- | --- | --- | | `allocations` | [MarketAllocation](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults#market) | The respective allocations in each market chosen. | onlyGuardianRole Functions[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#onlyguardianrole-functions) ---------------------------------------------------------------------------------------------------------------------------------- Note that owner and guardian has the `onlyAllocatorRole`. ### revokePendingTimelock[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#revokependingtimelock) Copy `function revokePendingTimelock() external onlyGuardianRole {};` Revokes the pending timelock. * Does not revert if there is no pending timelock. ### revokePendingGuardian[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#revokependingguardian) Copy `function revokePendingGuardian() external onlyGuardianRole {};` Revokes the pending guardian. onlyCuratorOrGuardianRole Functions[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#onlycuratororguardianrole-functions) ---------------------------------------------------------------------------------------------------------------------------------------------------- Note that owner, curator and guardian has the `onlyAllocatorRole`. ### revokePendingCap[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#revokependingcap) Copy `function revokePendingCap(Id id) external onlyCuratorOrGuardianRole {};` Revokes the pending cap of the market defined by `id`. * Does not revert if there is no pending cap. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#parameters-20) | Name | Type | Description | | --- | --- | --- | | `id` | [Id](https://docs.morpho.org/get-started/resources/contracts/morpho#market-id) | The id of the market to revoke the pending cap. | ### revokePendingMarketRemoval[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#revokependingmarketremoval) Copy `function revokePendingMarketRemoval(Id id) external onlyCuratorOrGuardianRole {};` Revokes the pending removal of the market defined by `id`. * Does not revert if there is no pending market removal. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho-vaults/#parameters-21) | Name | Type | Description | | --- | --- | --- | | `id` | [Id](https://docs.morpho.org/get-started/resources/contracts/morpho#market-id) | The id of the market to revoke the pending removal. | Below is a list of the different **Errors** that can be thrown when executing transactions on Morpho Vaults. **E.g**: One can try to execute an action on Morpho Vaults' contracts, and get: Copy `reverted with an unrecognized custom error (return data: 0x46fedb57)` According to the following tables, this is an error that emitted the **AboveMaxTimelock()** function. | Custom Error | Error Signature (returned data) | | --- | --- | | `AboveMaxTimelock()` | 0x46fedb57 | | `AlreadyPending()` | 0x49b204ce | | `AlreadySet()` | 0xa741a045 | | `AllCapsReached()` | 0xded0652d | | `BelowMinTimelock()` | 0x342b27be | | `DuplicateMarket(Id id)` | 0x074e4d4b | | `InconsistentAsset(Id id)` | 0xf17887ec | | `InconsistentReallocation()` | 0x9e36b890 | | `InvalidMarketRemovalNonZeroCap(Id id)` | 0xd2575d1a | | `InvalidMarketRemovalNonZeroSupply(Id id)` | 0x6316104f | | `InvalidMarketRemovalTimelockNotElapsed(Id id)` | 0x813435c5 | | `MarketNotCreated()` | 0x96e13529 | | `MarketNotEnabled(Id id)` | 0x11b0e0ab | | `MaxFeeExceeded()` | 0xf4df6ae5 | | `MaxQueueLengthExceeded()` | 0x80f2f7ae | | `NonZeroCap()` | 0xc48e3172 | | `NoPendingValue()` | 0xe5f408a5 | | `NotAllocatorRole()` | 0xf7137c0f | | `NotCuratorNorGuardianRole()` | 0xd080fa31 | | `NotCuratorRole()` | 0xca899cec | | `NotEnoughLiquidity()` | 0x4323a555 | | `NotGuardianRole()` | 0xf9f2fc9a | | `PendingCap(Id id)` | 0x42288ef1 | | `PendingRemoval()` | 0x4bec0146 | | `SupplyCapExceeded(Id id)` | 0xd018394f | | `TimelockNotElapsed()` | 0x6677a596 | | `UnauthorizedMarket(Id id)` | 0x9cd14834 | | `ZeroAddress()` | 0x867915ab | | `ZeroFeeRecipient()` | 0xcff9f194 | --- # Morpho – Morpho Docs [Skip to content](https://docs.morpho.org/get-started/resources/contracts/morpho/#vocs-content) Search... [](https://docs.morpho.org/) [](https://docs.morpho.org/) Get Started Chevron Down Menu Morpho On this page Chevron Right [← Back to contracts](https://docs.morpho.org/get-started/resources/contracts) Code[](https://docs.morpho.org/get-started/resources/contracts/morpho/#code) ------------------------------------------------------------------------------- [Morpho repository](https://github.com/morpho-org/morpho-blue/tree/731e3f7ed97cf15f8fe00b86e4be5365eb3802ac) Market Parameters[](https://docs.morpho.org/get-started/resources/contracts/morpho/#market-parameters) --------------------------------------------------------------------------------------------------------- ### Market id[](https://docs.morpho.org/get-started/resources/contracts/morpho/#market-id) The market id is a `bytes32` keccak256 hash of the [5 parameters of a market](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) . It is used to identify a market in Morpho. Copy `type Id is bytes32;` To get the id from the parameters, a temporary solution is to execute [this gist](https://gist.github.com/tomrpl/3cfd34e04a01f9cbae2b16887f8026cf) , or retrieve the id at market creation. ### Market struct[](https://docs.morpho.org/get-started/resources/contracts/morpho/#market-struct) The market struct is defined as follows: Copy `struct Market { uint128 totalSupplyAssets; uint128 totalSupplyShares; uint128 totalBorrowAssets; uint128 totalBorrowShares; uint128 lastUpdate; uint128 fee; }` It contains the state of a market. `totalBorrowAssets` & `totalSupplyAssets` accrues the interest of the market only until last interest accrual, while `totalBorrowShares` & `totalSupplyShares` are representing the total shares distributed over lenders / borrowers. ### MarketParams struct[](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) The majority of the entrypoints accept a `MarketParams` struct as parameter. This struct is defined as follows: Copy `struct MarketParams { address loanToken; address collateralToken; address oracle; address irm; uint256 lltv; }` As an integrator, you need to recover these 5 parameters to interact with Morpho. You can also use the [idToMarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#idtomarketparams) view function to recover the parameters of a given market from the bytes32 id. Functions[](https://docs.morpho.org/get-started/resources/contracts/morpho/#functions) ----------------------------------------------------------------------------------------- ### setOwner[](https://docs.morpho.org/get-started/resources/contracts/morpho/#setowner) Copy `function setOwner(address newOwner) external;` Sets `newOwner` as `owner` of the contract. * Warning: No two-step transfer ownership. * Warning: The owner can be set to the zero address. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters) | Name | Type | Description | | --- | --- | --- | | `newOwner` | address | The new owner address. | ### enableIrm[](https://docs.morpho.org/get-started/resources/contracts/morpho/#enableirm) Copy `function enableIrm(address irm) external;` Enables `irm` as a possible IRM for market creation. * Warning: It is not possible to disable an IRM. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-1) | Name | Type | Description | | --- | --- | --- | | `irm` | address | The irm address to enable. | ### enableLltv[](https://docs.morpho.org/get-started/resources/contracts/morpho/#enablelltv) Copy `function enableLltv(uint256 lltv) external;` Enables `lltv` as a possible LLTV for market creation. * Warning: It is not possible to disable a LLTV. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-2) | Name | Type | Description | | --- | --- | --- | | `lltv` | uint256 | The lltv value to enable (18 decimals). | ### setFee[](https://docs.morpho.org/get-started/resources/contracts/morpho/#setfee) Copy `function setFee(MarketParams memory marketParams, uint256 newFee) external;` Sets the `newFee` for the given market `marketParams`. * Warning: The recipient can be the zero address. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-3) | Name | Type | Description | | --- | --- | --- | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market parameters. | | `newFee` | uint256 | The new fee value. | ### setFeeRecipient[](https://docs.morpho.org/get-started/resources/contracts/morpho/#setfeerecipient) Copy `function setFeeRecipient(address newFeeRecipient) external;` Sets `newFeeRecipient` as `feeRecipient` of the fee. * Warning: If the fee recipient is set to the zero address, fees will accrue there and will be lost. * Modifying the fee recipient will allow the new recipient to claim any pending fees not yet accrued. To ensure that the current recipient receives all due fees, accrue interest manually prior to making any changes. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-4) | Name | Type | Description | | --- | --- | --- | | `newFeeRecipient` | address | The address of the new fee recipient. | ### createMarket[](https://docs.morpho.org/get-started/resources/contracts/morpho/#createmarket) Copy `function createMarket(MarketParams memory marketParams) external;` Creates the market defined by `marketParams`. Here is the list of assumptions on the market's dependencies (tokens, IRM and oracle) that guarantees Morpho behaves as expected: * The token should be ERC20 compliant, except that it can omit return values on `transfer` and `transferFrom`. * The token balance of Morpho should only decrease on `transfer` and `transferFrom`. In particular, tokens with burn functions are not supported. * The token should not re-enter Morpho on `transfer` nor `transferFrom`. * The token balance of the sender (resp. receiver) should decrease (resp. increase) by exactly the given amount on `transfer` and `transferFrom`. In particular, tokens with fees on transfer are not supported. * The IRM should not re-enter Morpho. * The oracle should return a price with the correct scaling. Here is a list of properties on the market's dependencies that could break Morpho's liveness properties: * The token can revert on `transfer` and `transferFrom` for a reason other than an approval or balance issue. * A very high amount of assets (~1e35) supplied or borrowed can make the computation of `toSharesUp` and `toSharesDown` overflow. * The IRM can revert on `borrowRate`. * A very high borrow rate returned by the IRM can make the computation of `interest` in `_accrueInterest` overflow. * The oracle can revert on `price`. Note that this can be used to prevent `borrow`, `withdrawCollateral` and `liquidate` from being used under certain market conditions. * A very high price returned by the oracle can make the computation of `maxBorrow` in `_isHealthy` overflow, or the computation of `assetsRepaid` in `liquidate` overflow. * The borrow share price of a market with less than 1e4 assets borrowed can be decreased by manipulations, to the point where `totalBorrowShares` is very large and borrowing overflows. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-5) | Name | Type | Description | | --- | --- | --- | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market parameters | ### supply[](https://docs.morpho.org/get-started/resources/contracts/morpho/#supply) Copy `function supply( MarketParams memory marketParams, uint256 assets, uint256 shares, address onBehalf, bytes memory data ) external returns (uint256 assetsSupplied, uint256 sharesSupplied);` Supplies `assets` or `shares` on behalf of `onBehalf`, optionally calling back the caller's `onMorphoSupply` function with the given `data`. * Either `assets` or `shares` should be zero. Most usecases should rely on `assets` as an input so the caller is guaranteed to have `assets` tokens pulled from their balance, but the possibility to mint a specific amount of shares is given for full compatibility and precision. * Supplying a large amount can revert for overflow. * Supplying an amount of shares may lead to supply more or fewer assets than expected due to slippage. Consider using the `assets` parameter to avoid this. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-6) | Name | Type | Description | | --- | --- | --- | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to supply assets to. | | `assets` | uint256 | The amount of assets to supply. | | `shares` | uint256 | The amount of shares to mint. | | `onBehalf` | address | The address that will own the increased supply position. | | `data` | bytes | Arbitrary data to pass to the `onMorphoSupply` callback. Pass empty data if not needed. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values) | Name | Type | Description | | --- | --- | --- | | `assetsSupplied` | uint256 | The amount of assets supplied. | | `sharesSupplied` | uint256 | The amount of shares minted. | ### withdraw[](https://docs.morpho.org/get-started/resources/contracts/morpho/#withdraw) Copy `function withdraw( MarketParams memory marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver ) external returns (uint256 assetsWithdrawn, uint256 sharesWithdrawn);` Withdraws `assets` or `shares` on behalf of `onBehalf` to `receiver`. * Either `assets` or `shares` should be zero. To withdraw max, pass the `shares`'s balance of `onBehalf`. * `msg.sender` must be authorized to manage `onBehalf`'s positions. * Withdrawing an amount corresponding to more shares than supplied will revert for underflow. * It is advised to use the `shares` input when withdrawing the full position to avoid reverts due to conversion roundings between `shares` and `assets`. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-7) | Name | Type | Description | | --- | --- | --- | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to withdraw assets from. | | `assets` | uint256 | The amount of assets to withdraw. | | `shares` | uint256 | The amount of shares to burn. | | `onBehalf` | address | The address of the owner of the supply position. | | `receiver` | address | The address that will receive the withdrawn assets. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-1) | Name | Type | Description | | --- | --- | --- | | `assetsWithdrawn` | uint256 | The amount of assets withdrawn. | | `sharesWithdrawn` | uint256 | The amount of shares burned. | ### borrow[](https://docs.morpho.org/get-started/resources/contracts/morpho/#borrow) Copy `function borrow( MarketParams memory marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver ) external returns (uint256 assetsBorrowed, uint256 sharesBorrowed);` Borrows `assets` or `shares` on behalf of `onBehalf` to `receiver`. * Either `assets` or `shares` should be zero. Most usecases should rely on `assets` as an input so the caller is guaranteed to borrow `assets` of tokens, but the possibility to mint a specific amount of shares is given for full compatibility and precision. * `msg.sender` must be authorized to manage `onBehalf`'s positions. * Borrowing a large amount can revert for overflow. * Borrowing an amount of shares may lead to borrow fewer assets than expected due to slippage. Consider using the `assets` parameter to avoid this. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-8) | Name | Type | Description | | --- | --- | --- | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to borrow assets from. | | `assets` | uint256 | The amount of assets to borrow. | | `shares` | uint256 | The amount of shares to mint. | | `onBehalf` | address | The address that will own the increased borrow position. | | `receiver` | address | The address that will receive the borrowed assets. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-2) | Name | Type | Description | | --- | --- | --- | | `assetsBorrowed` | uint256 | The amount of assets borrowed. | | `sharesBorrowed` | uint256 | The amount of shares minted. | ### repay[](https://docs.morpho.org/get-started/resources/contracts/morpho/#repay) Copy `function repay( MarketParams memory marketParams, uint256 assets, uint256 shares, address onBehalf, bytes memory data ) external returns (uint256 assetsRepaid, uint256 sharesRepaid);` Repays `assets` or `shares` on behalf of `onBehalf`, optionally calling back the caller's `onMorphoRepay` function with the given `data`. * Either `assets` or `shares` should be zero. To repay max, pass the `shares`'s balance of `onBehalf`. * Repaying an amount corresponding to more shares than borrowed will revert for underflow. * It is advised to use the `shares` input when repaying the full position to avoid reverts due to conversion roundings between shares and assets. * An attacker can front-run a repay with a small repay making the transaction revert for underflow. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-9) | Name | Type | Description | | --- | --- | --- | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to repay assets from. | | `assets` | uint256 | The amount of assets to repay. | | `shares` | uint256 | The amount of shares to burn. | | `onBehalf` | address | The address of the owner of the debt position. | | `data` | bytes | Arbitrary data (example `0x`) to pass to the `onMorphoRepay` callback. Pass empty data if not needed. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-3) | Name | Type | Description | | --- | --- | --- | | `assetsRepaid` | uint256 | The amount of assets repaid. | | `sharesRepaid` | uint256 | The amount of shares burned. | ### supplyCollateral[](https://docs.morpho.org/get-started/resources/contracts/morpho/#supplycollateral) Copy `function supplyCollateral(MarketParams memory marketParams, uint256 assets, address onBehalf, bytes memory data) external;` Supplies `assets` of collateral on behalf of `onBehalf`, optionally calling back the caller's `onMorphoSupplyCollateral` function with the given `data`. * Interest are not accrued since it's not required and it saves gas. * Supplying a large amount can revert for overflow. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-10) | Name | Type | Description | | --- | --- | --- | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to supply collateral to. | | `assets` | uint256 | The amount of assets to supply. | | `onBehalf` | address | The address that will own the increased collateral position. | | `data` | bytes | Arbitrary data to pass to the `onMorphoSupplyCollateral` callback. Pass empty data if not needed. | ### withdrawCollateral[](https://docs.morpho.org/get-started/resources/contracts/morpho/#withdrawcollateral) Copy `function withdrawCollateral(MarketParams memory marketParams, uint256 assets, address onBehalf, address receiver) external;` Withdraws `assets` of collateral on behalf of `onBehalf` to `receiver`. * `msg.sender` must be authorized to manage `onBehalf`'s positions. * Withdrawing an amount corresponding to more collateral than supplied will revert for underflow. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-11) | Name | Type | Description | | --- | --- | --- | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to withdraw collateral from. | | `assets` | uint256 | The amount of assets to withdraw. | | `onBehalf` | address | The address that owns the collateral position. | | `receiver` | address | The address that will receive the collateral assets. | ### liquidate[](https://docs.morpho.org/get-started/resources/contracts/morpho/#liquidate) Copy `function liquidate( MarketParams memory marketParams, address borrower, uint256 seizedAssets, uint256 repaidShares, bytes memory data ) external returns (uint256, uint256);` Liquidates the given `repaidShares` of debt asset or seize the given `seizedAssets` of collateral on the given market `marketParams` of the given `borrower`'s position, optionally calling back the caller's `onMorphoLiquidate` function with the given `data`. * Either `seizedAssets` or `repaidShares` should be zero. * Seizing more than the collateral balance will underflow and revert without any error message. * Repaying more than the borrow balance will underflow and revert without any error message. * An attacker can front-run a liquidation with a small repay making the transaction revert for underflow. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-12) | Name | Type | Description | | --- | --- | --- | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market of the position. | | `borrower` | address | The owner of the position. | | `seizedAssets` | uint256 | The amount of collateral to seize. | | `repaidShares` | uint256 | The amount of shares to repay. | | `data` | bytes | Arbitrary data to pass to the `onMorphoLiquidate` callback. Pass empty data if not needed. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-4) | Name | Type | Description | | --- | --- | --- | | `assetsSeized` | uint256 | The amount of assets seized. | | `assetsRepaid` | uint256 | The amount of assets repaid. | ### flashLoan[](https://docs.morpho.org/get-started/resources/contracts/morpho/#flashloan) Copy `function flashLoan(address token, uint256 assets, bytes calldata data) external;` Executes a flash loan. * Flash loans have access to the whole balance of the contract (the liquidity and deposited collateral of all markets combined, plus donations). * Warning: Not ERC-3156 compliant but compatibility is easily reached: a. `flashFee` is zero. b. `maxFlashLoan` is the token's balance of this contract. c. The receiver of `assets` is the caller. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-13) | Name | Type | Description | | --- | --- | --- | | `token` | address | The token to flash loan. | | `assets` | uint256 | The amount of assets to flash loan. | | `data` | bytes | Arbitrary data to pass to the `onMorphoFlashLoan` callback. | ### setAuthorization[](https://docs.morpho.org/get-started/resources/contracts/morpho/#setauthorization) Copy `function setAuthorization(address authorized, bool newIsAuthorized) external;` Sets the authorization for `authorized` to manage `msg.sender`'s positions. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-14) | Name | Type | Description | | --- | --- | --- | | `authorized` | address | The authorized address. | | `newIsAuthorized` | bool | The new authorization status. | ### setAuthorizationWithSig[](https://docs.morpho.org/get-started/resources/contracts/morpho/#setauthorizationwithsig) Copy `struct Authorization { address authorizer; address authorized; bool isAuthorized; uint256 nonce; uint256 deadline; } struct Signature { uint8 v; bytes32 r; bytes32 s; } function setAuthorizationWithSig(Authorization calldata authorization, Signature calldata signature) external;` Sets the authorization for `authorization.authorized` to manage `authorization.authorizer`'s positions. * Warning: Reverts if the signature has already been submitted. * The signature is malleable, but it has no impact on the security here. * The nonce is passed as argument to be able to revert with a different error message. #### Authorization struct[](https://docs.morpho.org/get-started/resources/contracts/morpho/#authorization-struct) | Name | Type | Description | | --- | --- | --- | | `authorizer` | address | The address authorizing the authorization. | | `authorized` | address | The address to authorize. | | `isAuthorized` | bool | The new authorization status. | | `nonce` | uint256 | The nonce of the authorizer. | | `deadline` | uint256 | The deadline after which the signature is invalid. | #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-15) | Name | Type | Description | | --- | --- | --- | | `authorization` | [Authorization](https://docs.morpho.org/get-started/resources/contracts/morpho/#authorization-struct) | The authorization to set. | | `signature` | Signature | The signature to validate. | ### accrueInterest[](https://docs.morpho.org/get-started/resources/contracts/morpho/#accrueinterest) Copy `function accrueInterest(MarketParams memory marketParams) external;` Accrues interest for the given market `marketParams`. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-16) | Name | Type | Description | | --- | --- | --- | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market parameters. | Views Functions[](https://docs.morpho.org/get-started/resources/contracts/morpho/#views-functions) ----------------------------------------------------------------------------------------------------- ### DOMAIN\_SEPARATOR[](https://docs.morpho.org/get-started/resources/contracts/morpho/#domain_separator) Copy `function DOMAIN_SEPARATOR() external view returns (bytes32);` The EIP-712 domain separator. * Warning: Every EIP-712 signed message based on this domain separator can be reused on another chain sharing the same chain id because the domain separator would be the same. #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-5) | Type | Description | | --- | --- | | bytes32 | The EIP-712 domain separator. | ### owner[](https://docs.morpho.org/get-started/resources/contracts/morpho/#owner) Copy `function owner() external view returns (address);` The owner of the contract. * It has the power to change the owner. * It has the power to set fees on markets and set the fee recipient. * It has the power to enable but not disable IRMs and LLTVs. #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-6) | Type | Description | | --- | --- | | address | The owner of the contract. | ### feeRecipient[](https://docs.morpho.org/get-started/resources/contracts/morpho/#feerecipient) Copy `function feeRecipient() external view returns (address);` The fee recipient of all markets. * The recipient receives the fees of a given market through a supply position on that market. #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-7) | Type | Description | | --- | --- | | address | The fee recipient address. | ### isIrmEnabled[](https://docs.morpho.org/get-started/resources/contracts/morpho/#isirmenabled) Copy `function isIrmEnabled(address irm) external view returns (bool);` Whether the `irm` is enabled. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-17) | Name | Type | Description | | --- | --- | --- | | `irm` | address | The irm address. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-8) | Type | Description | | --- | --- | | bool | Boolean equals to `true` if irm is enabled, `false` otherwise. | ### isLltvEnabled[](https://docs.morpho.org/get-started/resources/contracts/morpho/#islltvenabled) Copy `function isLltvEnabled(uint256 lltv) external view returns (bool);` Whether the `lltv` is enabled. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-18) | Name | Type | Description | | --- | --- | --- | | `lltv` | address | The lltv address. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-9) | Type | Description | | --- | --- | | bool | Boolean equals to `true` if lltv is enabled, `false` otherwise. | ### isAuthorized[](https://docs.morpho.org/get-started/resources/contracts/morpho/#isauthorized) Copy `function isAuthorized(address authorizer, address authorized) external view returns (bool);` Whether `authorized` is authorized to modify `authorizer`'s position on all markets. * Anyone is authorized to modify their own positions, regardless of this variable. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-19) | Name | Type | Description | | --- | --- | --- | | `authorizer` | address | The authorizer address. | | `authorized` | address | The authorized address. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-10) | Type | Description | | --- | --- | | bool | Boolean equals to `true` if `authorized` address is authorized to modify `authorizer`'s position, `false` otherwise. | ### nonce[](https://docs.morpho.org/get-started/resources/contracts/morpho/#nonce) Copy `function nonce(address authorizer) external view returns (uint256);` The `authorizer`'s current nonce. Used to prevent replay attacks with EIP-712 signatures. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-20) | Name | Type | Description | | --- | --- | --- | | `authorizer` | address | The authorizer address. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-11) | Type | Description | | --- | --- | | uint256 | The current nonce value. | ### extSloads[](https://docs.morpho.org/get-started/resources/contracts/morpho/#extsloads) Copy `function extSloads(bytes32[] memory slots) external view returns (bytes32[] memory);` Returns the data stored on the different `slots`. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-21) | Name | Type | Description | | --- | --- | --- | | `slots` | bytes32\[\] | The array of slots to retrieve the data stored into. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-12) | Type | Description | | --- | --- | | bytes32\[\] | The data stored. | ### idToMarketParams[](https://docs.morpho.org/get-started/resources/contracts/morpho/#idtomarketparams) Copy `function idToMarketParams(Id id) external view returns (address loanToken, address collateralToken, address oracle, address irm, uint256 lltv);` The market params corresponding to `id`. * This mapping is not used in Morpho. It is there to enable reducing the cost associated to calldata on layer 2s by creating a wrapper contract with functions that take `id` as input instead of `marketParams`. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-22) | Name | Type | Description | | --- | --- | --- | | `id` | Id | The market id | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-13) | Name | Type | Description | | --- | --- | --- | | `loanToken` | address | The loan token of the market. | | `collateralToken` | address | The collateral token of the market. | | `oracle` | address | The oracle of the market. | | `irm` | address | The IRM of the market. | | `lltv` | uint256 | The LLTV of the market. | ### market[](https://docs.morpho.org/get-started/resources/contracts/morpho/#market) Copy `function market(Id id) external view returns ( uint128 totalSupplyAssets, uint128 totalSupplyShares, uint128 totalBorrowAssets, uint128 totalBorrowShares, uint128 lastUpdate, uint128 fee );` The market state corresponding to `id`. * Interest are not accrued, and assets values are not updated. Their values are the one at the last update. * One can use the [MorphoBalancesLib](https://docs.morpho.org/get-started/resources/contracts/morpho/#morphobalanceslib) to accrue interests #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-23) | Name | Type | Description | | --- | --- | --- | | `id` | Id | The market id | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-14) | Name | Type | Description | | --- | --- | --- | | `totalSupplyAssets` | uint128 | The total supply assets of the market. | | `totalSupplyShares` | uint128 | The total supply shares of the market. | | `totalBorrowAssets` | uint128 | The total borrow assets of the market. | | `totalBorrowShares` | uint128 | The total borrow shares of the market. | | `lastUpdate` | uint128 | The last update timestamp of the market. | | `fee` | uint128 | The fee of the market. | ### position[](https://docs.morpho.org/get-started/resources/contracts/morpho/#position) Copy `function position(Id id, address user) external view returns (uint256 supplyShares, uint128 borrowShares, uint128 collateral);` The state of the position of `user` on the market corresponding to `id`. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-24) | Name | Type | Description | | --- | --- | --- | | `id` | Id | The market id. | | `user` | address | The user address. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-15) | Name | Type | Description | | --- | --- | --- | | `supplyShares` | uint256 | The total supply shares of the user on a given market. | | `borrowShares` | uint128 | The total borrow shares of the user on a given market. | | `collateral` | uint128 | The total collateral assets of the user on a given market. | MorphoBalancesLib[](https://docs.morpho.org/get-started/resources/contracts/morpho/#morphobalanceslib) --------------------------------------------------------------------------------------------------------- > The Github code is available [**here**](https://github.com/morpho-org/morpho-blue/blob/be2306afd655232d2cf16547c18be0077014bae0/src/libraries/periphery/MorphoBalancesLib.sol) ### expectedMarketBalances[](https://docs.morpho.org/get-started/resources/contracts/morpho/#expectedmarketbalances) Copy `function expectedMarketBalances(IMorpho morpho, MarketParams memory marketParams) internal view returns ( uint256 totalSupplyAssets, uint256 totalSupplyShares, uint256 totalBorrowAssets, uint256 totalBorrowShares );` Returns the expected market balances of a market after having accrued interests, defined in [Market](https://docs.morpho.org/get-started/resources/contracts/morpho/#market-struct) . #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-25) | Name | Type | Description | | --- | --- | --- | | `morpho` | IMorpho | The Morpho contract (injected when used as library). | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to get the expected balances from. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-16) | Name | Type | Description | | --- | --- | --- | | `totalSupplyAssets` | uint256 | The total supply assets of the market (with interests accrued). | | `totalSupplyShares` | uint256 | The total supply shares of the market. | | `totalBorrowAssets` | uint256 | The total borrow assets of the market (with interests accrued). | | `totalBorrowShares` | uint256 | The total borrow shares of the market. | ### expectedTotalSupplyAssets[](https://docs.morpho.org/get-started/resources/contracts/morpho/#expectedtotalsupplyassets) Copy `function expectedTotalSupplyAssets(IMorpho morpho, MarketParams memory marketParams) internal view returns (uint256 totalSupplyAssets);` Returns the expected total supply assets of a market after having accrued interests. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-26) | Name | Type | Description | | --- | --- | --- | | `morpho` | IMorpho | The Morpho contract (injected when used as library). | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to get the expected total supply from. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-17) | Name | Type | Description | | --- | --- | --- | | `totalSupplyAssets` | uint256 | The total supply assets of the market (with interests accrued). | ### expectedTotalBorrowAssets[](https://docs.morpho.org/get-started/resources/contracts/morpho/#expectedtotalborrowassets) Copy `function expectedTotalBorrowAssets(IMorpho morpho, MarketParams memory marketParams) internal view returns (uint256 totalBorrowAssets);` Returns the expected total borrow assets of a market after having accrued interests. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-27) | Name | Type | Description | | --- | --- | --- | | `morpho` | IMorpho | The Morpho contract (injected when used as library). | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to get the expected total borrow from. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-18) | Name | Type | Description | | --- | --- | --- | | `totalBorrowAssets` | uint256 | The total borrow assets of the market (with interests accrued). | ### expectedTotalSupplyShares[](https://docs.morpho.org/get-started/resources/contracts/morpho/#expectedtotalsupplyshares) Copy `function expectedTotalSupplyShares(IMorpho morpho, MarketParams memory marketParams) internal view returns (uint256 totalSupplyShares);` Returns the expected total supply shares of a market after having accrued interests. * It can grow only if fees > 0 #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-28) | Name | Type | Description | | --- | --- | --- | | `morpho` | IMorpho | The Morpho contract (injected when used as library). | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to get the expected total supply from. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-19) | Name | Type | Description | | --- | --- | --- | | `totalSupplyShares` | uint256 | The total supply shares of the market (with interests accrued). | ### expectedSupplyAssets[](https://docs.morpho.org/get-started/resources/contracts/morpho/#expectedsupplyassets) Copy `function expectedSupplyAssets(IMorpho morpho, MarketParams memory marketParams, address user) internal view returns (uint256)` Returns the expected supply assets of a user on a market after having accrued interests. * Warning: Wrong for `feeRecipient` because their supply shares increase is not taken into account. * Warning: Withdrawing using the expected supply assets can lead to a revert due to conversion roundings from assets to shares. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-29) | Name | Type | Description | | --- | --- | --- | | `morpho` | IMorpho | The Morpho contract (injected when used as library). | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to get the expected supply assets from. | | `user` | address | The user to get the expected supply assets from. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-20) | Name | Type | Description | | --- | --- | --- | | `supplyAssets` | uint256 | The supply assets of the user (with interests accrued). | ### expectedBorrowAssets[](https://docs.morpho.org/get-started/resources/contracts/morpho/#expectedborrowassets) Copy `function expectedBorrowAssets(IMorpho morpho, MarketParams memory marketParams, address user) internal view returns (uint256)` Returns the expected borrow assets of a user on a market after having accrued interests. * Warning: The expected balance is rounded up, so it may be greater than the market's expected total borrow assets. #### Parameters:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#parameters-30) | Name | Type | Description | | --- | --- | --- | | `morpho` | IMorpho | The Morpho contract (injected when used as library). | | `marketParams` | [MarketParams](https://docs.morpho.org/get-started/resources/contracts/morpho/#marketparams-struct) | The market to get the expected borrow assets from. | | `user` | address | The user to get the expected borrow assets from. | #### Return Values:[](https://docs.morpho.org/get-started/resources/contracts/morpho/#return-values-21) | Name | Type | Description | | --- | --- | --- | | `borrowBalance` | uint256 | The borrow assets of the user (with interests accrued). | Errors Codes[](https://docs.morpho.org/get-started/resources/contracts/morpho/#errors-codes) ----------------------------------------------------------------------------------------------- The full list of custom errors are displayed directly in the ErrorsLib of the [Morpho contracts](https://github.com/morpho-org/morpho-blue/blob/main/src/libraries/ErrorsLib.sol) . For example, see the [Morpho contract deployed on Ethereum mainnet](https://etherscan.io/address/0xbbbbbbbbbb9cc5e90e3b3af64bdaf62c37eeffcb#code#F10#L1) . Below is the list of the different **Errors** that can be thrown, along with their explanations: | Errors Message (returned data) | Error Natspec | | --- | --- | | "already set" | Thrown when the value is already set. | | "healthy position" | Thrown when the position to liquidate is healthy. | | "inconsistent input" | Thrown when not exactly one of the input amount is zero. | | "insufficient collateral" | Thrown when the collateral is insufficient to `borrow` or `withdrawCollateral`. | | "insufficient liquidity" | Thrown when the liquidity is insufficient to `withdraw` or `borrow`. | | "invalid nonce" | Thrown when the nonce is invalid. | | "invalid signature" | Thrown when the authorization signature is invalid. | | "irm not enabled" | Thrown when the IRM is not enabled at market creation. | | "lltv not enabled" | Thrown when the LLTV is not enabled at market creation. | | "market already created" | Thrown when the market is already created. | | "market not created" | Thrown when the market is not created. | | "max fee exceeded" | Thrown when the fee to set exceeds the maximum fee. | | "max lltv exceeded" | Thrown when the LLTV to enable exceeds the maximum LLTV. | | "max uint128 exceeded" | Thrown when the maximum uint128 is exceeded. | | "no code" | Thrown when a token to transfer doesn't have code. | | "not owner" | Thrown when the caller is not the owner. | | "signature expired" | Thrown when the authorization signature is expired. | | "transfer from reverted" | Thrown when a token transferFrom reverted. | | "transfer from returned false" | Thrown when a token transferFrom returned false. | | "transfer returned false" | Thrown when a token transfer returned false. | | "transfer reverted" | Thrown when a token transfer reverted. | | "unauthorized" | Thrown when the caller is not authorized to conduct an action. | | "zero address" | Thrown when a zero address is passed as input. | | "zero assets" | Thrown when zero assets is passed as input. | --- # Fetch Rewards Data – Morpho Docs [Skip to content](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#vocs-content) Search... [](https://docs.morpho.org/) [](https://docs.morpho.org/) Build Products Chevron Down Menu Fetch Rewards Data On this page Chevron Right This tutorial shows you how to fetch reward information for Morpho Vaults and Markets from both **Merkl API** and **Morpho API**. Understanding how to query both systems is essential for displaying complete reward information to your users. What You'll Learn[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#what-youll-learn) ----------------------------------------------------------------------------------------------------------- * How to fetch vault and market reward rates from Morpho API * How to query user-specific rewards from Merkl API * How to get historical reward data from Morpho Rewards API (URD) * How to combine data from multiple sources for a complete picture Prerequisites[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#prerequisites) ---------------------------------------------------------------------------------------------------- * Basic understanding of [Reward Programs](https://docs.morpho.org/build/rewards/concepts/reward-campaigns) * Familiarity with REST and GraphQL APIs * A tool for making API requests (curl, fetch, axios, or GraphQL client) API Landscape Overview[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#api-landscape-overview) ---------------------------------------------------------------------------------------------------------------------- There are **three main APIs** for rewards data: | API | Use Case | Rewards Type | Data Provided | | --- | --- | --- | --- | | **Morpho API** | Vault/Market reward rates | Both Merkl & Old URD | APRs, reward token info, integrated with vault/market data | | **Merkl API** | User claimable rewards | Merkl only | User balances, claim data, real-time rewards | | **Rewards API** | Historical rewards | URD only | Legacy programs, distributions, claim data | **Recommended Strategy:** 1. Use **Morpho API** for displaying reward APRs on vaults/markets (easiest integration) 2. Use **Merkl API** for user-specific Merkl rewards 3. Use **Rewards API** for user-specific URD (legacy) rewards Fetching Vault Rewards[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#fetching-vault-rewards) ---------------------------------------------------------------------------------------------------------------------- ### Using Morpho API (Recommended)[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#using-morpho-api-recommended) Vault rewards come from **two sources** that must be queried and aggregated manually: 1. **Vault-level rewards**: Direct campaigns targeting the vault 2. **Market-level rewards**: Forwarded from markets where the vault allocates #### Query Complete Vault Rewards[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#query-complete-vault-rewards) Copy `query VaultRewards($address: String!, $chainId: Int!) { vaultByAddress(address: $address, chainId: $chainId) { address name symbol state { apy netApy # Convenience field: complete APY including rewards # Vault-level rewards (direct) rewards { supplyApr yearlySupplyTokens asset { address symbol priceUsd chain { id } } } # Market-level rewards (forwarded from allocations) allocation { supplyAssetsUsd # Required for weighted average market { uniqueKey loanAsset { symbol } collateralAsset { symbol } state { rewards { supplyApr asset { address symbol priceUsd chain { id } } } } } } } } }` **Variables:** Copy `{ "address": "0x9aB2d181E4b87ba57D5eD564D3eF652C4E710707", "chainId": 8453 }` #### Calculate Total Rewards APR[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#calculate-total-rewards-apr) Vault rewards require **manual aggregation** with weighted averaging: Copy ``const vault = response.data.vaultByAddress; // 1. Sum vault-level rewards const vaultRewardsApr = vault.state.rewards.reduce( (sum, r) => sum + parseFloat(r.supplyApr), 0 ); // 2. Calculate weighted average of market-level rewards const totalAllocatedUsd = vault.state.allocation.reduce( (sum, alloc) => sum + parseFloat(alloc.supplyAssetsUsd), 0 ); const marketRewardsApr = vault.state.allocation.reduce((sum, alloc) => { const marketRewards = alloc.market.state.rewards.reduce( (marketSum, r) => marketSum + parseFloat(r.supplyApr), 0 ); const weight = parseFloat(alloc.supplyAssetsUsd) / totalAllocatedUsd; return sum + (marketRewards * weight); }, 0); // 3. Total rewards APR const totalRewardsApr = vaultRewardsApr + marketRewardsApr; console.log(`Base APY: ${vault.state.apy}%`); console.log(`Vault Rewards APR: ${vaultRewardsApr}%`); console.log(`Market Rewards APR: ${marketRewardsApr}%`); console.log(`Total APY: ${parseFloat(vault.state.apy) + totalRewardsApr}%`);`` #### Alternative: Use Convenience Fields[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#alternative-use-convenience-fields) For simple total APY display without breakdown: Copy ``const vault = response.data.vaultByAddress; const netApy = parseFloat(vault.state.netApy); // Pre-calculated complete APY console.log(`Total APY: ${netApy}%`);`` **Important Notes:** * Vault rewards are in **two separate API locations**: `state.rewards` and `state.allocation[].market.state.rewards` * Manual weighted average calculation is required for market rewards * Use `supplyAssetsUsd` from allocations to calculate weights * Convenience field `netApy` includes all components but doesn't provide breakdown Fetching Market Rewards[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#fetching-market-rewards) ------------------------------------------------------------------------------------------------------------------------ Markets can have rewards for **supply** and **borrow**. ### Using Morpho API[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#using-morpho-api) Copy `query MarketRewards($uniqueKey: String!) { markets(where: { uniqueKey: $uniqueKey }) { items { uniqueKey loanAsset { symbol } collateralAsset { symbol } state { borrowApy supplyApy rewards { supplyApr borrowApr asset { address symbol priceUsd } } } } } }` **Key Fields:** * `supplyApr`: Reward APR for suppliers * `borrowApr`: Reward APR for borrowers (often negative, meaning borrowers earn rewards) Fetching User-Specific Rewards[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#fetching-user-specific-rewards) -------------------------------------------------------------------------------------------------------------------------------------- ### Merkl API (Current Programs)[](https://docs.morpho.org/build/rewards/tutorials/fetch-rewards-data#merkl-api-current-programs) To get a user's claimable Merkl rewards: **Endpoint:** Copy `GET https://api.merkl.xyz/v4/userRewards?user={address}` **Example:** Copy `curl "https://api.merkl.xyz/v4/userRewards?user=0x1234...5678"` **Response Structure:** Copy `{ "1": { // Chain ID "0xVAULT_OR_MARKET_ADDRESS": { "claimable": { "0xREWARD_TOKEN_ADDRESS": { "accumulated": "1234567890", "unclaimed": "1234567890", "symbol": "MORPHO", "decimals": 18 } } } } }` **TypeScript Example:** Copy ``async function fetchMerklRewards(userAddress: string) { const response = await fetch( `https://api.merkl.xyz/v4/userRewards?user=${userAddress}` ); const data = await response.json(); // Parse rewards by chain const chainId = 1; // Ethereum mainnet const rewards = data[chainId] || {}; // Aggregate all claimable rewards const claimableByToken: Record
Loading...
; if (!data) return No data
; return ( {data.vault}
Deposit {data.asset}
{/* Total APY */}Total APY: {data.totalApy.toFixed(2)}%
Base APY: {data.baseApy.toFixed(2)}%
Rewards APR: +{data.rewardsApr.toFixed(2)}%
Reward Programs:
{data.rewards.map((reward) => ( {reward.token} {reward.apr.toFixed(2)}% APR
))} Total APY {totalApy.toFixed(2)}%
`
**Show Breakdown on Hover/Click:**
Copy
`Base APY: {baseApy}%
MORPHO Rewards: +{morphoApr}%
Partner Rewards: +{partnerApr}%
}> {totalApy}% Loading rewards...
; if (!rewards || rewards.total.length === 0) { return No claimable rewards
; } return ( Your Claimable Rewards
{rewards.total.map((reward) => ( {reward.symbol} {formatUnits(reward.amount, 18)} {reward.symbol}
))} {/* Show separate counts for transparency */} Merkl: {rewards.merkl.length} rewards • URD: {rewards.urd.length} rewards
{/* Claim button */} | Vault | Your Deposit | Base APY | Rewards APR | Total APY | Claimable |
|---|---|---|---|---|---|
| {vault.name} | {vault.userDeposit} {vault.asset.symbol} | {vault.baseApy.toFixed(2)}% | +{vault.rewardsApr.toFixed(2)}% | {vault.totalApy.toFixed(2)}% | {vault.claimable > 0 ? ( ) : ( — )} |
Active Reward Programs
{programs.map((program) => (APR: {program.apr.toFixed(2)}%
Ends: {formatDate(program.endDate)}
Source: {program.isMerkl ? "Merkl" : "Morpho URD"}
Accruing: {accrued.toFixed(6)} MORPHO
); }`
Handling Edge Cases[](https://docs.morpho.org/build/rewards/tutorials/integrate-display#handling-edge-cases)
---------------------------------------------------------------------------------------------------------------
###
No Rewards Available[](https://docs.morpho.org/build/rewards/tutorials/integrate-display#no-rewards-available)
Copy
`{rewards.length === 0 ? ( No active reward programs for this vault
Check back later or explore other vaults
Unable to load rewards data