@morpho-org/consumer-sdk 0.4.0 → 0.5.0

package/lib/actions/marketV1/repayWithdrawCollateral.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketV1RepayWithdrawCollateral = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const bundler_sdk_viem_1 = require("@morpho-org/bundler-sdk-viem");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
+const helpers_1 = require("../../helpers");
+const types_1 = require("../../types");
+const getRequirementsAction_1 = require("../requirements/getRequirementsAction");
+/**
+ * Prepares an atomic repay-and-withdraw-collateral transaction for a Morpho Blue market.
+ *
+ * Routed through bundler3. The bundle order is critical:
+ * 1. ERC20 transfer (loan token to GeneralAdapter1)
+ * 2. `morphoRepay` — reduces debt FIRST
+ * 3. `morphoWithdrawCollateral` — then withdraws collateral
+ *
+ * If the order were reversed, Morpho would revert because the position would be
+ * insolvent at the time of the withdraw.
+ *
+ * Supports two repay modes:
+ * - **By assets** (`assets > 0, shares = 0`): repays an exact asset amount.
+ * - **By shares** (`assets = 0, shares > 0`): repays exact shares (full repay).
+ *
+ * **Prerequisites:**
+ * - ERC20 approval for loan token to GeneralAdapter1 (for the repay).
+ * - GeneralAdapter1 must be authorized on Morpho (for the withdraw).
+ *
+ * @param params - Combined repay and withdraw collateral parameters.
+ * @returns Deep-frozen transaction.
+ */
+const marketV1RepayWithdrawCollateral = ({ market: { chainId, marketParams }, args: { assets, shares, transferAmount, withdrawAmount, onBehalf, receiver, maxSharePrice, requirementSignature, }, metadata, }) => {
+    (0, helpers_1.validateRepayParams)({
+        assets,
+        shares,
+        transferAmount,
+        maxSharePrice,
+        marketId: marketParams.id,
+    });
+    if (withdrawAmount <= 0n) {
+        throw new types_1.NonPositiveWithdrawCollateralAmountError(marketParams.id);
+    }
+    const { bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    const actions = [];
+    if (requirementSignature) {
+        actions.push(...(0, getRequirementsAction_1.getRequirementsAction)({
+            chainId,
+            asset: marketParams.loanToken,
+            amount: transferAmount,
+            requirementSignature,
+        }));
+    }
+    else {
+        actions.push({
+            type: "erc20TransferFrom",
+            args: [marketParams.loanToken, transferAmount, generalAdapter1, false],
+        });
+    }
+    // REPAY FIRST — reduces debt before withdrawing collateral
+    actions.push({
+        type: "morphoRepay",
+        args: [marketParams, assets, shares, maxSharePrice, onBehalf, [], false],
+    });
+    // Skim residual loan tokens back to the payer when repaying by shares.
+    // In shares mode, transferAmount is an upper-bound estimate; morphoRepay
+    // consumes only the exact amount needed, leaving a residual in the adapter.
+    if (shares > 0n) {
+        actions.push({
+            type: "erc20Transfer",
+            args: [
+                marketParams.loanToken,
+                receiver,
+                viem_1.maxUint256,
+                generalAdapter1,
+                false,
+            ],
+        });
+    }
+    actions.push({
+        type: "morphoWithdrawCollateral",
+        args: [marketParams, withdrawAmount, receiver, false],
+    });
+    let tx = {
+        ...bundler_sdk_viem_1.BundlerAction.encodeBundle(chainId, actions),
+        value: 0n,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "marketV1RepayWithdrawCollateral",
+            args: {
+                market: marketParams.id,
+                repayAssets: assets,
+                repayShares: shares,
+                transferAmount,
+                withdrawAmount,
+                maxSharePrice,
+                onBehalf,
+                receiver,
+            },
+        },
+    });
+};
+exports.marketV1RepayWithdrawCollateral = marketV1RepayWithdrawCollateral;

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

@@ -0,0 +1,28 @@
+import { type MarketParams } from "@morpho-org/blue-sdk";
+import type { Address } from "viem";
+import { type DepositAmountArgs, type MarketV1SupplyCollateralAction, type Metadata, type RequirementSignature, type Transaction } from "../../types";
+/** Parameters for {@link marketV1SupplyCollateral}. */
+export interface MarketV1SupplyCollateralParams {
+    market: {
+        readonly chainId: number;
+        readonly marketParams: MarketParams;
+    };
+    args: DepositAmountArgs & {
+        onBehalf: Address;
+        requirementSignature?: RequirementSignature;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a supply-collateral transaction for a Morpho Blue market.
+ *
+ * Routed through bundler via GeneralAdapter1.
+ * When `nativeAmount` is provided, native token is wrapped via GeneralAdapter1.
+ * Collateral token must be the chain's wNative when `nativeAmount` is used.
+ *
+ * Zero loss: all collateral reaches Morpho. No dust left in bundler or adapter.
+ *
+ * @param params - Supply collateral parameters.
+ * @returns Deep-frozen transaction.
+ */
+export declare const marketV1SupplyCollateral: ({ market: { chainId, marketParams }, args: { amount, onBehalf, requirementSignature, nativeAmount }, metadata, }: MarketV1SupplyCollateralParams) => Readonly<Transaction<MarketV1SupplyCollateralAction>>;

package/lib/actions/marketV1/supplyCollateral.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketV1SupplyCollateral = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const bundler_sdk_viem_1 = require("@morpho-org/bundler-sdk-viem");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const helpers_1 = require("../../helpers");
+const types_1 = require("../../types");
+const getRequirementsAction_1 = require("../requirements/getRequirementsAction");
+/**
+ * Prepares a supply-collateral transaction for a Morpho Blue market.
+ *
+ * Routed through bundler via GeneralAdapter1.
+ * When `nativeAmount` is provided, native token is wrapped via GeneralAdapter1.
+ * Collateral token must be the chain's wNative when `nativeAmount` is used.
+ *
+ * Zero loss: all collateral reaches Morpho. No dust left in bundler or adapter.
+ *
+ * @param params - Supply collateral parameters.
+ * @returns Deep-frozen transaction.
+ */
+const marketV1SupplyCollateral = ({ market: { chainId, marketParams }, args: { amount = 0n, onBehalf, requirementSignature, nativeAmount }, metadata, }) => {
+    if (amount < 0n) {
+        throw new types_1.NonPositiveAssetAmountError(marketParams.collateralToken);
+    }
+    if (nativeAmount !== undefined && nativeAmount < 0n) {
+        throw new types_1.NegativeNativeAmountError(nativeAmount);
+    }
+    const totalCollateral = amount + (nativeAmount ?? 0n);
+    if (totalCollateral === 0n) {
+        throw new types_1.ZeroCollateralAmountError(marketParams.id);
+    }
+    const { bundler3: { generalAdapter1, bundler3 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    const actions = [];
+    if (nativeAmount !== undefined && nativeAmount > 0n) {
+        (0, helpers_1.validateNativeCollateral)(chainId, marketParams.collateralToken);
+        actions.push({
+            type: "nativeTransfer",
+            args: [bundler3, generalAdapter1, nativeAmount, false],
+        }, {
+            type: "wrapNative",
+            args: [nativeAmount, generalAdapter1, false],
+        });
+    }
+    if (amount > 0n) {
+        if (requirementSignature) {
+            actions.push(...(0, getRequirementsAction_1.getRequirementsAction)({
+                chainId,
+                asset: marketParams.collateralToken,
+                amount,
+                requirementSignature,
+            }));
+        }
+        else {
+            actions.push({
+                type: "erc20TransferFrom",
+                args: [marketParams.collateralToken, amount, generalAdapter1, false],
+            });
+        }
+    }
+    actions.push({
+        type: "morphoSupplyCollateral",
+        args: [marketParams, totalCollateral, onBehalf, [], false],
+    });
+    let tx = {
+        ...bundler_sdk_viem_1.BundlerAction.encodeBundle(chainId, actions),
+        value: nativeAmount ?? 0n,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "marketV1SupplyCollateral",
+            args: {
+                market: marketParams.id,
+                amount: totalCollateral,
+                onBehalf,
+                nativeAmount,
+            },
+        },
+    });
+};
+exports.marketV1SupplyCollateral = marketV1SupplyCollateral;

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

@@ -0,0 +1,37 @@
+import { type MarketParams } from "@morpho-org/blue-sdk";
+import type { Address } from "viem";
+import { type DepositAmountArgs, type MarketV1SupplyCollateralBorrowAction, type Metadata, type RequirementSignature, type Transaction, type VaultReallocation } from "../../types";
+/** Parameters for {@link marketV1SupplyCollateralBorrow}. */
+export interface MarketV1SupplyCollateralBorrowParams {
+    market: {
+        readonly chainId: number;
+        readonly marketParams: MarketParams;
+    };
+    args: DepositAmountArgs & {
+        borrowAmount: bigint;
+        onBehalf: Address;
+        receiver: Address;
+        /** Minimum borrow share price (in ray). Protects against share price manipulation. */
+        minSharePrice: bigint;
+        requirementSignature?: RequirementSignature;
+        /** Vault reallocations to execute before borrowing (computed by entity). */
+        reallocations?: readonly VaultReallocation[];
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares an atomic supply-collateral-and-borrow transaction for a Morpho Blue market.
+ *
+ * Routed through the bundler: collateral transfer + `morphoSupplyCollateral` + `morphoBorrow`.
+ * When `nativeAmount` is provided, native ETH is wrapped via GeneralAdapter1.
+ *
+ * **Prerequisite:** GeneralAdapter1 must be authorized on Morpho to borrow on behalf of the user.
+ * Use `getRequirements()` on the entity to check and obtain the authorization transaction.
+ *
+ * Zero loss: all collateral reaches Morpho, all borrowed tokens reach the receiver.
+ * No dust left in bundler or adapter.
+ *
+ * @param params - Combined supply collateral and borrow parameters.
+ * @returns Deep-frozen transaction.
+ */
+export declare const marketV1SupplyCollateralBorrow: ({ market: { chainId, marketParams }, args: { amount, borrowAmount, onBehalf, receiver, minSharePrice, requirementSignature, nativeAmount, reallocations, }, metadata, }: MarketV1SupplyCollateralBorrowParams) => Readonly<Transaction<MarketV1SupplyCollateralBorrowAction>>;

package/lib/actions/marketV1/supplyCollateralBorrow.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketV1SupplyCollateralBorrow = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const bundler_sdk_viem_1 = require("@morpho-org/bundler-sdk-viem");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const helpers_1 = require("../../helpers");
+const types_1 = require("../../types");
+const getRequirementsAction_1 = require("../requirements/getRequirementsAction");
+const buildReallocationActions_1 = require("./buildReallocationActions");
+/**
+ * Prepares an atomic supply-collateral-and-borrow transaction for a Morpho Blue market.
+ *
+ * Routed through the bundler: collateral transfer + `morphoSupplyCollateral` + `morphoBorrow`.
+ * When `nativeAmount` is provided, native ETH is wrapped via GeneralAdapter1.
+ *
+ * **Prerequisite:** GeneralAdapter1 must be authorized on Morpho to borrow on behalf of the user.
+ * Use `getRequirements()` on the entity to check and obtain the authorization transaction.
+ *
+ * Zero loss: all collateral reaches Morpho, all borrowed tokens reach the receiver.
+ * No dust left in bundler or adapter.
+ *
+ * @param params - Combined supply collateral and borrow parameters.
+ * @returns Deep-frozen transaction.
+ */
+const marketV1SupplyCollateralBorrow = ({ market: { chainId, marketParams }, args: { amount = 0n, borrowAmount, onBehalf, receiver, minSharePrice, requirementSignature, nativeAmount, reallocations, }, metadata, }) => {
+    if (amount < 0n) {
+        throw new types_1.NonPositiveAssetAmountError(marketParams.collateralToken);
+    }
+    if (nativeAmount !== undefined && nativeAmount < 0n) {
+        throw new types_1.NegativeNativeAmountError(nativeAmount);
+    }
+    if (borrowAmount <= 0n) {
+        throw new types_1.NonPositiveBorrowAmountError(marketParams.id);
+    }
+    if (minSharePrice < 0n) {
+        throw new types_1.NonPositiveMinBorrowSharePriceError(marketParams.id);
+    }
+    const totalCollateral = amount + (nativeAmount ?? 0n);
+    if (totalCollateral === 0n) {
+        throw new types_1.ZeroCollateralAmountError(marketParams.id);
+    }
+    const { bundler3: { generalAdapter1, bundler3 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    const actions = [];
+    if (nativeAmount !== undefined && nativeAmount > 0n) {
+        (0, helpers_1.validateNativeCollateral)(chainId, marketParams.collateralToken);
+        actions.push({
+            type: "nativeTransfer",
+            args: [bundler3, generalAdapter1, nativeAmount, false],
+        }, {
+            type: "wrapNative",
+            args: [nativeAmount, generalAdapter1, false],
+        });
+    }
+    if (amount > 0n) {
+        if (requirementSignature) {
+            actions.push(...(0, getRequirementsAction_1.getRequirementsAction)({
+                chainId,
+                asset: marketParams.collateralToken,
+                amount,
+                requirementSignature,
+            }));
+        }
+        else {
+            actions.push({
+                type: "erc20TransferFrom",
+                args: [marketParams.collateralToken, amount, generalAdapter1, false],
+            });
+        }
+    }
+    actions.push({
+        type: "morphoSupplyCollateral",
+        args: [marketParams, totalCollateral, onBehalf, [], false],
+    });
+    let reallocationFee = 0n;
+    if (reallocations && reallocations.length > 0) {
+        const result = (0, buildReallocationActions_1.buildReallocationActions)(reallocations, marketParams);
+        actions.push(...result.actions);
+        reallocationFee = result.fee;
+    }
+    actions.push({
+        type: "morphoBorrow",
+        args: [marketParams, borrowAmount, 0n, minSharePrice, receiver, false],
+    });
+    let tx = {
+        ...bundler_sdk_viem_1.BundlerAction.encodeBundle(chainId, actions),
+        value: (nativeAmount ?? 0n) + reallocationFee,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "marketV1SupplyCollateralBorrow",
+            args: {
+                market: marketParams.id,
+                collateralAmount: totalCollateral,
+                borrowAmount,
+                minSharePrice,
+                onBehalf,
+                receiver,
+                nativeAmount,
+                reallocationFee,
+            },
+        },
+    });
+};
+exports.marketV1SupplyCollateralBorrow = marketV1SupplyCollateralBorrow;

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

@@ -0,0 +1,28 @@
+import { type MarketParams } from "@morpho-org/blue-sdk";
+import { type Address } from "viem";
+import { type MarketV1WithdrawCollateralAction, type Metadata, type Transaction } from "../../types";
+/** Parameters for {@link marketV1WithdrawCollateral}. */
+export interface MarketV1WithdrawCollateralParams {
+    market: {
+        readonly chainId: number;
+        readonly marketParams: MarketParams;
+    };
+    args: {
+        amount: bigint;
+        onBehalf: Address;
+        receiver: Address;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a withdraw-collateral transaction for a Morpho Blue market.
+ *
+ * Direct call to `morpho.withdrawCollateral`. No bundler needed — collateral
+ * flows out of Morpho, so there is no attack surface requiring the bundler.
+ *
+ * The caller (`msg.sender`) must be `onBehalf` or be authorized by them.
+ *
+ * @param params - Withdraw collateral parameters.
+ * @returns Deep-frozen transaction.
+ */
+export declare const marketV1WithdrawCollateral: ({ market: { chainId, marketParams }, args: { amount, onBehalf, receiver }, metadata, }: MarketV1WithdrawCollateralParams) => Readonly<Transaction<MarketV1WithdrawCollateralAction>>;

package/lib/actions/marketV1/withdrawCollateral.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketV1WithdrawCollateral = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const blue_sdk_viem_1 = require("@morpho-org/blue-sdk-viem");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
+const helpers_1 = require("../../helpers");
+const types_1 = require("../../types");
+/**
+ * Prepares a withdraw-collateral transaction for a Morpho Blue market.
+ *
+ * Direct call to `morpho.withdrawCollateral`. No bundler needed — collateral
+ * flows out of Morpho, so there is no attack surface requiring the bundler.
+ *
+ * The caller (`msg.sender`) must be `onBehalf` or be authorized by them.
+ *
+ * @param params - Withdraw collateral parameters.
+ * @returns Deep-frozen transaction.
+ */
+const marketV1WithdrawCollateral = ({ market: { chainId, marketParams }, args: { amount, onBehalf, receiver }, metadata, }) => {
+    if (amount <= 0n) {
+        throw new types_1.NonPositiveWithdrawCollateralAmountError(marketParams.id);
+    }
+    const { morpho } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    let tx = {
+        to: morpho,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: blue_sdk_viem_1.blueAbi,
+            functionName: "withdrawCollateral",
+            args: [marketParams, amount, onBehalf, receiver],
+        }),
+        value: 0n,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "marketV1WithdrawCollateral",
+            args: {
+                market: marketParams.id,
+                amount,
+                onBehalf,
+                receiver,
+            },
+        },
+    });
+};
+exports.marketV1WithdrawCollateral = marketV1WithdrawCollateral;

package/lib/actions/requirements/encode/encodeErc20Permit.js

@@ -45,11 +45,14 @@ const encodeErc20Permit = async (viemClient, params) => {
                 ...typedData,
                 account: client.account,
             });
-            await (0, viem_1.verifyTypedData)({
+            const isValid = await (0, viem_1.verifyTypedData)({
                 ...typedData,
                 address: userAddress, // Verify against the permit's owner.
                 signature,
             });
+            if (!isValid) {
+                throw new types_1.InvalidSignatureError();
+            }
             return (0, morpho_ts_1.deepFreeze)({
                 args: {
                     owner: userAddress,

package/lib/actions/requirements/encode/encodeErc20Permit2.js

@@ -44,11 +44,14 @@ const encodeErc20Permit2 = (params) => {
                 ...typedData,
                 account: client.account,
             });
-            await (0, viem_1.verifyTypedData)({
+            const isValid = await (0, viem_1.verifyTypedData)({
                 ...typedData,
                 address: userAddress,
                 signature,
             });
+            if (!isValid) {
+                throw new types_1.InvalidSignatureError();
+            }
             return (0, morpho_ts_1.deepFreeze)({
                 args: {
                     owner: userAddress,

package/lib/actions/requirements/getMorphoAuthorizationRequirement.d.ts

@@ -0,0 +1,21 @@
+import type { Client } from "viem";
+import { type Address } from "viem";
+import { type MorphoAuthorizationAction, type Transaction } from "../../types";
+/**
+ * Checks whether GeneralAdapter1 is authorized on Morpho for the given user.
+ * If not authorized, returns a deep-frozen `morpho.setAuthorization(generalAdapter1, true)` transaction.
+ * Returns `null` if authorization is already in place.
+ *
+ * Required before any bundled borrow on behalf of the user (e.g. `supplyCollateralBorrow`).
+ *
+ * @param params - Request parameters.
+ * @param params.viemClient - Connected viem client.
+ * @param params.chainId - Target chain ID (used to look up Morpho and GeneralAdapter1 addresses).
+ * @param params.userAddress - The user who needs to authorize GeneralAdapter1.
+ * @returns Deep-frozen authorization transaction, or `null` if already authorized.
+ */
+export declare const getMorphoAuthorizationRequirement: (params: {
+    viemClient: Client;
+    chainId: number;
+    userAddress: Address;
+}) => Promise<Readonly<Transaction<MorphoAuthorizationAction>> | null>;

package/lib/actions/requirements/getMorphoAuthorizationRequirement.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMorphoAuthorizationRequirement = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const blue_sdk_viem_1 = require("@morpho-org/blue-sdk-viem");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
+const types_1 = require("../../types");
+/**
+ * Checks whether GeneralAdapter1 is authorized on Morpho for the given user.
+ * If not authorized, returns a deep-frozen `morpho.setAuthorization(generalAdapter1, true)` transaction.
+ * Returns `null` if authorization is already in place.
+ *
+ * Required before any bundled borrow on behalf of the user (e.g. `supplyCollateralBorrow`).
+ *
+ * @param params - Request parameters.
+ * @param params.viemClient - Connected viem client.
+ * @param params.chainId - Target chain ID (used to look up Morpho and GeneralAdapter1 addresses).
+ * @param params.userAddress - The user who needs to authorize GeneralAdapter1.
+ * @returns Deep-frozen authorization transaction, or `null` if already authorized.
+ */
+const getMorphoAuthorizationRequirement = async (params) => {
+    const { viemClient, chainId, userAddress } = params;
+    if (viemClient.chain?.id !== chainId) {
+        throw new types_1.ChainIdMismatchError(viemClient.chain?.id, chainId);
+    }
+    const { morpho, bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    const pc = viemClient.extend(viem_1.publicActions);
+    const isAuthorized = await pc.readContract({
+        address: morpho,
+        abi: blue_sdk_viem_1.blueAbi,
+        functionName: "isAuthorized",
+        args: [userAddress, generalAdapter1],
+    });
+    if (isAuthorized) {
+        return null;
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        to: morpho,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: blue_sdk_viem_1.blueAbi,
+            functionName: "setAuthorization",
+            args: [generalAdapter1, true],
+        }),
+        value: 0n,
+        action: {
+            type: "morphoAuthorization",
+            args: {
+                authorized: generalAdapter1,
+                isAuthorized: true,
+            },
+        },
+    });
+};
+exports.getMorphoAuthorizationRequirement = getMorphoAuthorizationRequirement;

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

@@ -1,4 +1,5 @@
 export * from "./encode/index";
+export * from "./getMorphoAuthorizationRequirement";
 export * from "./getRequirements";
 export * from "./getRequirementsApproval";
 export * from "./getRequirementsPermit";

package/lib/actions/requirements/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./encode/index"), exports);
+__exportStar(require("./getMorphoAuthorizationRequirement"), exports);
 __exportStar(require("./getRequirements"), exports);
 __exportStar(require("./getRequirementsApproval"), exports);
 __exportStar(require("./getRequirementsPermit"), exports);

package/lib/actions/vaultV2/forceWithdraw.js

@@ -39,7 +39,11 @@ const vaultV2ForceWithdraw = ({ vault: { address: vaultAddress }, args: { deallo
     }
     const totalDeallocated = deallocations.reduce((sum, d) => sum + d.amount, 0n);
     if (withdraw.amount < totalDeallocated) {
-        throw new types_1.DeallocationsExceedWithdrawError(vaultAddress, withdraw.amount, totalDeallocated);
+        throw new types_1.DeallocationsExceedWithdrawError({
+            vault: vaultAddress,
+            withdrawAmount: withdraw.amount,
+            totalDeallocated,
+        });
     }
     const calls = [];
     for (const deallocation of deallocations) {

package/lib/client/morphoClient.d.ts

@@ -1,5 +1,6 @@
+import type { MarketParams } from "@morpho-org/blue-sdk";
 import type { Address, Client } from "viem";
-import { MorphoVaultV1, MorphoVaultV2 } from "../entities";
+import { MorphoMarketV1, MorphoVaultV1, MorphoVaultV2 } from "../entities";
 import type { Metadata, MorphoClientType } from "../types";
 export declare class MorphoClient implements MorphoClientType {
     readonly viemClient: Client;
@@ -20,4 +21,5 @@ export declare class MorphoClient implements MorphoClientType {
     } | undefined);
     vaultV1(vault: Address, chainId: number): MorphoVaultV1;
     vaultV2(vault: Address, chainId: number): MorphoVaultV2;
+    marketV1(marketParams: MarketParams, chainId: number): MorphoMarketV1;
 }

package/lib/client/morphoClient.js

@@ -21,5 +21,8 @@ class MorphoClient {
     vaultV2(vault, chainId) {
         return new entities_1.MorphoVaultV2(this, vault, chainId);
     }
+    marketV1(marketParams, chainId) {
+        return new entities_1.MorphoMarketV1(this, marketParams, chainId);
+    }
 }
 exports.MorphoClient = MorphoClient;

package/lib/entities/index.d.ts

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

package/lib/entities/index.js

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

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

@@ -0,0 +1 @@
+export * from "./marketV1";

package/lib/entities/marketV1/index.js

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