feat(morpho-sdk): add native wrapping to blueRepay

Allow funding part or all of a Blue repay's transferAmount by wrapping
native into wNative via GeneralAdapter1, mirroring blueSupply /
blueSupplyCollateral. Adds the optional nativeAmount arg, the
BlueRepayAction.nativeAmount field, and the exported
NativeAmountExceedsTransferAmountError.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Foulks-Plb

.changeset/blue-repay-native-wrapping.md

@@ -0,0 +1,5 @@
+---
+"@morpho-org/morpho-sdk": minor
+---
+
+Add native-wrapping support to `blueRepay`. The action now accepts an optional `args.nativeAmount` that funds part or all of `transferAmount` by wrapping native into wNative via `GeneralAdapter1.wrapNative()` (the remainder is pulled via the ERC-20 path), mirroring the native-wrapping flow already available on `blueSupply` / `blueSupplyCollateral`. Requires the market's loan token to be the chain's wNative. The new `BlueRepayAction.args.nativeAmount` field and the `NativeAmountExceedsTransferAmountError` class are exported as public API.

packages/morpho-sdk/AGENTS.md

@@ -7,7 +7,7 @@ Transaction builders for VaultV1, VaultV2, and Blue. Subfolders carry the layer-
 ## Routing summary
 
 - **VaultV1 / VaultV2 deposits** route through bundler3 via GeneralAdapter1 (which enforces `maxSharePrice`, protecting against inflation attacks). VaultV1/V2 `withdraw` and `redeem` are direct vault calls. VaultV2 `forceWithdraw` / `forceRedeem` use `multicall` with `forceDeallocate` calls before the final withdraw/redeem.
-- **Blue bundled paths** (`supply`, `supplyCollateral`, `borrow`, `supplyCollateralBorrow`, `repay`, `repayWithdrawCollateral`, `withdraw`) route through bundler3 via GeneralAdapter1. `repay` and `withdraw` each accept assets or shares (mutually exclusive); `repayWithdrawCollateral` repays first then withdraws. Loan-asset `supply` supports native wrapping when `loanToken === wNative`; loan-asset `withdraw` supports optional PublicAllocator reallocations to top up market liquidity (same mechanism as `borrow`).
+- **Blue bundled paths** (`supply`, `supplyCollateral`, `borrow`, `supplyCollateralBorrow`, `repay`, `repayWithdrawCollateral`, `withdraw`) route through bundler3 via GeneralAdapter1. `repay` and `withdraw` each accept assets or shares (mutually exclusive); `repayWithdrawCollateral` repays first then withdraws. Loan-asset `supply` and `repay` support native wrapping when `loanToken === wNative` (for `repay`, `nativeAmount` funds part or all of `transferAmount`); loan-asset `withdraw` supports optional PublicAllocator reallocations to top up market liquidity (same mechanism as `borrow`).
 - **Bundle composition, native wrapping, and reallocation rules** are canonical in [`src/actions/AGENTS.md`](./src/actions/AGENTS.md).
 
 ## Tests

packages/morpho-sdk/src/actions/blue/repay.test.ts

@@ -1,11 +1,14 @@
-import { getChainAddresses } from "@morpho-org/blue-sdk";
+import { addressesRegistry, getChainAddresses } from "@morpho-org/blue-sdk";
 import { parseUnits } from "viem";
 import { mainnet } from "viem/chains";
 import { afterEach, describe, expect, vi } from "vitest";
 import { WethUsdsBlue } from "../../../test/fixtures/blue.js";
 import { test } from "../../../test/setup.js";
 import {
   MutuallyExclusiveRepayAmountsError,
+  NativeAmountExceedsTransferAmountError,
+  NativeAmountOnNonWNativeAssetError,
+  NegativeNativeAmountError,
   NonPositiveRepayAmountError,
   NonPositiveRepayMaxSharePriceError,
   NonPositiveTransferAmountError,
@@ -24,6 +27,14 @@ describe("blueRepay unit tests", () => {
     bundler3: { bundler3 },
   } = getChainAddresses(mainnet.id);
 
+  const { wNative } = addressesRegistry[mainnet.id];
+
+  /** Market params with wNative as loan token — enables native wrapping tests. */
+  const wNativeLoanMarketParams = {
+    ...WethUsdsBlue,
+    loanToken: wNative,
+  };
+
   test("should create repay-by-assets transaction", async ({ client }) => {
     const assets = parseUnits("1000", 6);
 
@@ -440,4 +451,161 @@ describe("blueRepay unit tests", () => {
     expect(txWith.data.includes("a1b2c3d4")).toBe(true);
     expect(txWith.action.type).toBe("blueRepay");
   });
+
+  test("should fully fund repay-by-assets via native wrapping", async ({
+    client,
+  }) => {
+    const assets = parseUnits("1", 18);
+
+    const localSpy = vi.spyOn(
+      getRequirementsActionModule,
+      "getRequirementsAction",
+    );
+
+    const tx = blueRepay({
+      market: {
+        chainId: mainnet.id,
+        marketParams: wNativeLoanMarketParams,
+      },
+      args: {
+        assets,
+        shares: 0n,
+        transferAmount: assets,
+        nativeAmount: assets,
+        onBehalf: client.account.address,
+        receiver: client.account.address,
+        maxSharePrice: 1n,
+      },
+    });
+
+    expect(tx.action.type).toBe("blueRepay");
+    expect(tx.action.args.nativeAmount).toBe(assets);
+    // tx.value is derived from the nativeTransfer call by encodeBundle.
+    expect(tx.value).toBe(assets);
+    expect(tx.to).toBe(bundler3);
+    // Fully native funding — no ERC-20 transfer and no requirement actions.
+    expect(localSpy).not.toHaveBeenCalled();
+  });
+
+  test("should fund repay with mixed native and ERC-20 amounts", async ({
+    client,
+  }) => {
+    const nativeAmount = parseUnits("0.4", 18);
+    const transferAmount = parseUnits("1", 18);
+
+    const tx = blueRepay({
+      market: {
+        chainId: mainnet.id,
+        marketParams: wNativeLoanMarketParams,
+      },
+      args: {
+        assets: transferAmount,
+        shares: 0n,
+        transferAmount,
+        nativeAmount,
+        onBehalf: client.account.address,
+        receiver: client.account.address,
+        maxSharePrice: 1n,
+      },
+    });
+
+    expect(tx.action.args.nativeAmount).toBe(nativeAmount);
+    // Only the native portion carries value; the remainder is pulled via ERC-20.
+    expect(tx.value).toBe(nativeAmount);
+    expect(tx.to).toBe(bundler3);
+  });
+
+  test("should keep the shares-mode skim when funding via native", async ({
+    client,
+  }) => {
+    const shares = parseUnits("500", 6);
+    const transferAmount = parseUnits("0.6", 18);
+
+    const tx = blueRepay({
+      market: {
+        chainId: mainnet.id,
+        marketParams: wNativeLoanMarketParams,
+      },
+      args: {
+        assets: 0n,
+        shares,
+        transferAmount,
+        nativeAmount: transferAmount,
+        onBehalf: client.account.address,
+        receiver: client.account.address,
+        maxSharePrice: 1n,
+      },
+    });
+
+    expect(tx.value).toBe(transferAmount);
+    // Residual (wNative) is still skimmed back to the receiver in shares mode.
+    const maxUint256Hex = "f".repeat(64);
+    expect(tx.data.toLowerCase()).toContain(maxUint256Hex);
+  });
+
+  test("should throw NegativeNativeAmountError when nativeAmount is negative", async ({
+    client,
+  }) => {
+    expect(() =>
+      blueRepay({
+        market: {
+          chainId: mainnet.id,
+          marketParams: wNativeLoanMarketParams,
+        },
+        args: {
+          assets: parseUnits("1", 18),
+          shares: 0n,
+          transferAmount: parseUnits("1", 18),
+          nativeAmount: -1n,
+          onBehalf: client.account.address,
+          receiver: client.account.address,
+          maxSharePrice: 1n,
+        },
+      }),
+    ).toThrow(NegativeNativeAmountError);
+  });
+
+  test("should throw NativeAmountExceedsTransferAmountError when nativeAmount > transferAmount", async ({
+    client,
+  }) => {
+    expect(() =>
+      blueRepay({
+        market: {
+          chainId: mainnet.id,
+          marketParams: wNativeLoanMarketParams,
+        },
+        args: {
+          assets: parseUnits("1", 18),
+          shares: 0n,
+          transferAmount: parseUnits("1", 18),
+          nativeAmount: parseUnits("2", 18),
+          onBehalf: client.account.address,
+          receiver: client.account.address,
+          maxSharePrice: 1n,
+        },
+      }),
+    ).toThrow(NativeAmountExceedsTransferAmountError);
+  });
+
+  test("should throw NativeAmountOnNonWNativeAssetError when loan token is not wNative", async ({
+    client,
+  }) => {
+    expect(() =>
+      blueRepay({
+        market: {
+          chainId: mainnet.id,
+          marketParams: WethUsdsBlue,
+        },
+        args: {
+          assets: parseUnits("1000", 6),
+          shares: 0n,
+          transferAmount: parseUnits("1000", 6),
+          nativeAmount: parseUnits("1000", 6),
+          onBehalf: client.account.address,
+          receiver: client.account.address,
+          maxSharePrice: 1n,
+        },
+      }),
+    ).toThrow(NativeAmountOnNonWNativeAssetError);
+  });
 });

packages/morpho-sdk/src/actions/blue/repay.ts

@@ -4,13 +4,16 @@ import { type Address, maxUint256 } from "viem";
 import { type Action, BundlerAction } from "../../bundler/index.js";
 import {
   addTransactionMetadata,
+  validateNativeAsset,
   validateRepayParams,
 } from "../../helpers/index.js";
-import type {
-  BlueRepayAction,
-  Metadata,
-  RequirementSignature,
-  Transaction,
+import {
+  type BlueRepayAction,
+  type Metadata,
+  NativeAmountExceedsTransferAmountError,
+  NegativeNativeAmountError,
+  type RequirementSignature,
+  type Transaction,
 } from "../../types/index.js";
 import { getRequirementsAction } from "../requirements/getRequirementsAction.js";
 
@@ -37,6 +40,13 @@ export interface BlueRepayParams {
     receiver: Address;
     /** Maximum repay share price (in ray). Protects against share price manipulation. */
     maxSharePrice: bigint;
+    /**
+     * Optional portion of `transferAmount` to fund by wrapping native into wNative
+     * (via `GeneralAdapter1.wrapNative()`) instead of pulling ERC-20. Must be
+     * `<= transferAmount`; the remainder (`transferAmount - nativeAmount`) is pulled
+     * via the ERC-20 path. Requires the loan token to be the chain's wNative.
+     */
+    nativeAmount?: bigint;
     requirementSignature?: RequirementSignature;
   };
   metadata?: Metadata;
@@ -55,6 +65,11 @@ export interface BlueRepayParams {
  * Exactly one of `assets` / `shares` must be non-zero. Uses `maxSharePrice` to protect against
  * share price manipulation between transaction construction and execution.
  *
+ * When `nativeAmount > 0`, that portion of `transferAmount` is funded by wrapping native ETH via
+ * `GeneralAdapter1.wrapNative()` (the loan token must be the chain's wNative); any remaining
+ * `transferAmount - nativeAmount` is pulled via the ERC-20 path. In shares mode the skimmed
+ * residual is returned to `receiver` as wNative, not unwrapped native.
+ *
  * @param params.market.chainId - The chain the market lives on.
  * @param params.market.marketParams - Market params (loanToken, collateralToken, oracle, irm, lltv).
  * @param params.args.assets - Repay amount in loan-token assets. Set to `0n` when repaying by shares.
@@ -67,8 +82,11 @@ export interface BlueRepayParams {
  * @param params.args.receiver - Address that receives residual loan tokens in shares mode.
  * @param params.args.maxSharePrice - Maximum acceptable repay share price (in ray). Slippage
  *   protection.
+ * @param params.args.nativeAmount - Optional portion of `transferAmount` to fund by wrapping
+ *   native into wNative. Must be `<= transferAmount`. Requires the loan token to be the chain's
+ *   wNative. The remainder is pulled via the ERC-20 path.
  * @param params.args.requirementSignature - Optional pre-signed permit/permit2 approval for the
- *   loan-token transfer.
+ *   ERC-20 portion of the loan-token transfer.
  * @param params.metadata - Optional analytics metadata attached to the bundle.
  * @returns A deep-frozen `Transaction<BlueRepayAction>` with `to`, `value`, `data`, and the
  *   typed `action` discriminator the simulation layer consumes.
@@ -78,6 +96,11 @@ export interface BlueRepayParams {
  * @throws {MutuallyExclusiveRepayAmountsError} when both `assets` and `shares` are non-zero.
  * @throws {NonPositiveTransferAmountError} when `transferAmount <= 0n`.
  * @throws {TransferAmountNotEqualToAssetsError} when in assets mode and `transferAmount !== assets`.
+ * @throws {NegativeNativeAmountError} when `nativeAmount < 0n`.
+ * @throws {NativeAmountExceedsTransferAmountError} when `nativeAmount > transferAmount`.
+ * @throws {ChainWNativeMissingError} when `nativeAmount > 0n` but the chain has no configured wNative.
+ * @throws {NativeAmountOnNonWNativeAssetError} when `nativeAmount > 0n` but the loan token is not
+ *   the chain's wNative.
  * @throws {DepositAssetMismatchError} from `getRequirementsAction` when `requirementSignature`
  *   is provided and the signed asset differs from `marketParams.loanToken`.
  * @throws {DepositAmountMismatchError} from `getRequirementsAction` when `requirementSignature`
@@ -111,6 +134,7 @@ export const blueRepay = ({
     onBehalf,
     receiver,
     maxSharePrice,
+    nativeAmount,
     requirementSignature,
   },
   metadata,
@@ -123,26 +147,60 @@ export const blueRepay = ({
     marketId: marketParams.id,
   });
 
+  if (nativeAmount !== undefined && nativeAmount < 0n) {
+    throw new NegativeNativeAmountError(nativeAmount);
+  }
+
+  const nativeFunding = nativeAmount ?? 0n;
+
+  if (nativeFunding > transferAmount) {
+    throw new NativeAmountExceedsTransferAmountError(
+      nativeFunding,
+      transferAmount,
+    );
+  }
+
   const {
-    bundler3: { generalAdapter1 },
+    bundler3: { generalAdapter1, bundler3 },
   } = getChainAddresses(chainId);
 
   const actions: Action[] = [];
 
-  if (requirementSignature) {
+  // Wrap the native portion of transferAmount into wNative inside GeneralAdapter1.
+  if (nativeFunding > 0n) {
+    validateNativeAsset(chainId, marketParams.loanToken);
+
     actions.push(
-      ...getRequirementsAction({
-        asset: marketParams.loanToken,
-        amount: transferAmount,
-        recipient: generalAdapter1,
-        requirementSignature,
-      }),
+      {
+        type: "nativeTransfer",
+        args: [bundler3, generalAdapter1, nativeFunding, false],
+      },
+      {
+        type: "wrapNative",
+        args: [nativeFunding, generalAdapter1, false],
+      },
     );
-  } else {
-    actions.push({
-      type: "erc20TransferFrom",
-      args: [marketParams.loanToken, transferAmount, generalAdapter1, false],
-    });
+  }
+
+  // Pull the remaining (non-native) portion of transferAmount via ERC-20.
+  const erc20Funding = transferAmount - nativeFunding;
+
+  if (erc20Funding > 0n) {
+    if (requirementSignature) {
+      actions.push(
+        ...getRequirementsAction({
+          asset: marketParams.loanToken,
+          amount: erc20Funding,
+          recipient: generalAdapter1,
+          requirementSignature,
+        }),
+      );
+    } else {
+      actions.push({
+        type: "erc20TransferFrom",
+        args: [marketParams.loanToken, erc20Funding, generalAdapter1, false],
+      });
+    }
   }
 
   actions.push({
@@ -184,6 +242,7 @@ export const blueRepay = ({
         onBehalf,
         receiver,
         maxSharePrice,
+        nativeAmount,
       },
     },
   });

packages/morpho-sdk/src/types/action.ts

@@ -189,6 +189,11 @@ export interface BlueRepayAction
       onBehalf: Address;
       receiver: Address;
       maxSharePrice: bigint;
+      /**
+       * Portion of `transferAmount` funded by wrapping native into wNative.
+       * `undefined` when the repay is fully funded by an ERC-20 transfer.
+       */
+      nativeAmount?: bigint;
     }
   > {}