@morpho-org/consumer-sdk 0.2.0 → 0.3.0

package/lib/actions/vaultV2/forceRedeem.d.ts

@@ -0,0 +1,48 @@
+import { type Address } from "viem";
+import { type Deallocation, type Metadata, type Transaction, type VaultV2ForceRedeemAction } from "../../types";
+export interface VaultV2ForceRedeemParams {
+    vault: {
+        address: Address;
+    };
+    args: {
+        deallocations: readonly Deallocation[];
+        redeem: {
+            shares: bigint;
+            recipient: Address;
+        };
+        onBehalf: Address;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a force redeem transaction for the VaultV2 contract, using VaultV2's native `multicall`.
+ *
+ * This function encodes one or more `forceDeallocate` calls followed by a single `redeem`,
+ * executed atomically via VaultV2's `multicall`. This allows a user to free liquidity from
+ * adapters other than the liquidity adapter and redeem all their shares in one transaction.
+
+ *
+ * This is the share-based counterpart to `vaultV2ForceWithdraw`, useful when the user wants
+ * to redeem a maximum amount of shares rather than specifying an exact asset amount.
+ *
+ * The total assets passed to `forceDeallocate` calls must be greater than or equal to the
+ * asset-equivalent of the redeemed shares. The caller should apply a buffer on the deallocated
+ * amounts to account for share-price drift between submission and execution.
+ *
+ * A penalty is taken from `onBehalf` for each deallocation to discourage allocation manipulations.
+ * The penalty is applied as a share burn where assets are returned to the vault, so the share price
+ * remains stable (except for rounding).
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault contract address.
+ * @param {Object} params.args - The force redeem related parameters.
+ * @param {readonly Deallocation[]} params.args.deallocations - The list of deallocations to perform.
+ * @param {Object} params.args.redeem - The redeem parameters applied after deallocations.
+ * @param {bigint} params.args.redeem.shares - The amount of shares to redeem.
+ * @param {Address} params.args.redeem.recipient - The recipient of the redeemed assets.
+ * @param {Address} params.args.onBehalf - The address from which the penalty is taken (share owner).
+ * @param {Metadata} [params.metadata] - Optional analytics metadata to append.
+ * @returns {Readonly<Transaction<VaultV2ForceRedeemAction>>} The prepared multicall transaction.
+ */
+export declare const vaultV2ForceRedeem: ({ vault: { address: vaultAddress }, args: { deallocations, redeem, onBehalf }, metadata, }: VaultV2ForceRedeemParams) => Readonly<Transaction<VaultV2ForceRedeemAction>>;

package/lib/actions/vaultV2/forceRedeem.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultV2ForceRedeem = void 0;
+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 encodeDeallocation_1 = require("../../helpers/encodeDeallocation");
+const types_1 = require("../../types");
+/**
+ * Prepares a force redeem transaction for the VaultV2 contract, using VaultV2's native `multicall`.
+ *
+ * This function encodes one or more `forceDeallocate` calls followed by a single `redeem`,
+ * executed atomically via VaultV2's `multicall`. This allows a user to free liquidity from
+ * adapters other than the liquidity adapter and redeem all their shares in one transaction.
+
+ *
+ * This is the share-based counterpart to `vaultV2ForceWithdraw`, useful when the user wants
+ * to redeem a maximum amount of shares rather than specifying an exact asset amount.
+ *
+ * The total assets passed to `forceDeallocate` calls must be greater than or equal to the
+ * asset-equivalent of the redeemed shares. The caller should apply a buffer on the deallocated
+ * amounts to account for share-price drift between submission and execution.
+ *
+ * A penalty is taken from `onBehalf` for each deallocation to discourage allocation manipulations.
+ * The penalty is applied as a share burn where assets are returned to the vault, so the share price
+ * remains stable (except for rounding).
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault contract address.
+ * @param {Object} params.args - The force redeem related parameters.
+ * @param {readonly Deallocation[]} params.args.deallocations - The list of deallocations to perform.
+ * @param {Object} params.args.redeem - The redeem parameters applied after deallocations.
+ * @param {bigint} params.args.redeem.shares - The amount of shares to redeem.
+ * @param {Address} params.args.redeem.recipient - The recipient of the redeemed assets.
+ * @param {Address} params.args.onBehalf - The address from which the penalty is taken (share owner).
+ * @param {Metadata} [params.metadata] - Optional analytics metadata to append.
+ * @returns {Readonly<Transaction<VaultV2ForceRedeemAction>>} The prepared multicall transaction.
+ */
+const vaultV2ForceRedeem = ({ vault: { address: vaultAddress }, args: { deallocations, redeem, onBehalf }, metadata, }) => {
+    if (deallocations.length === 0) {
+        throw new types_1.EmptyDeallocationsError(vaultAddress);
+    }
+    if (redeem.shares === 0n) {
+        throw new types_1.ZeroSharesAmountError(vaultAddress);
+    }
+    const calls = [];
+    for (const deallocation of deallocations) {
+        calls.push((0, encodeDeallocation_1.encodeForceDeallocateCall)(deallocation, onBehalf));
+    }
+    calls.push((0, viem_1.encodeFunctionData)({
+        abi: blue_sdk_viem_1.vaultV2Abi,
+        functionName: "redeem",
+        args: [redeem.shares, redeem.recipient, onBehalf],
+    }));
+    let tx = {
+        to: vaultAddress,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: blue_sdk_viem_1.vaultV2Abi,
+            functionName: "multicall",
+            args: [calls],
+        }),
+        value: 0n,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "vaultV2ForceRedeem",
+            args: {
+                vault: vaultAddress,
+                deallocations: deallocations.map((d) => ({ ...d })),
+                redeem: {
+                    shares: redeem.shares,
+                    recipient: redeem.recipient,
+                },
+                onBehalf,
+            },
+        },
+    });
+};
+exports.vaultV2ForceRedeem = vaultV2ForceRedeem;

package/lib/actions/vaultV2/forceWithdraw.d.ts

@@ -0,0 +1,40 @@
+import { type Address } from "viem";
+import { type Deallocation, type Metadata, type Transaction, type VaultV2ForceWithdrawAction } from "../../types";
+export interface VaultV2ForceWithdrawParams {
+    vault: {
+        address: Address;
+    };
+    args: {
+        deallocations: readonly Deallocation[];
+        withdraw: {
+            assets: bigint;
+            recipient: Address;
+        };
+        onBehalf: Address;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a force withdraw transaction for the VaultV2 contract, using VaultV2's native `multicall`.
+ *
+ * This function encodes one or more `forceDeallocate` calls followed by a single `withdraw`,
+ * executed atomically via VaultV2's `multicall`. This allows a user to free liquidity from
+ * adapters other than the liquidity adapter and withdraw the resulting assets in one transaction.
+ *
+ * A penalty is taken from `onBehalf` for each deallocation to discourage allocation manipulations.
+ * The penalty is applied as a share burn where assets are returned to the vault, so the share price
+ * remains stable (except for rounding).
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault contract address.
+ * @param {Object} params.args - The force withdraw related parameters.
+ * @param {readonly Deallocation[]} params.args.deallocations - The list of deallocations to perform.
+ * @param {Object} params.args.withdraw - The withdraw parameters applied after deallocations.
+ * @param {bigint} params.args.withdraw.assets - The amount of assets to withdraw.
+ * @param {Address} params.args.withdraw.recipient - The recipient of the withdrawn assets.
+ * @param {Address} params.args.onBehalf - The address from which the penalty is taken (share owner).
+ * @param {Metadata} [params.metadata] - Optional analytics metadata to append.
+ * @returns {Readonly<Transaction<VaultV2ForceWithdrawAction>>} The prepared multicall transaction.
+ */
+export declare const vaultV2ForceWithdraw: ({ vault: { address: vaultAddress }, args: { deallocations, withdraw, onBehalf }, metadata, }: VaultV2ForceWithdrawParams) => Readonly<Transaction<VaultV2ForceWithdrawAction>>;

package/lib/actions/vaultV2/forceWithdraw.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultV2ForceWithdraw = void 0;
+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 encodeDeallocation_1 = require("../../helpers/encodeDeallocation");
+const types_1 = require("../../types");
+/**
+ * Prepares a force withdraw transaction for the VaultV2 contract, using VaultV2's native `multicall`.
+ *
+ * This function encodes one or more `forceDeallocate` calls followed by a single `withdraw`,
+ * executed atomically via VaultV2's `multicall`. This allows a user to free liquidity from
+ * adapters other than the liquidity adapter and withdraw the resulting assets in one transaction.
+ *
+ * A penalty is taken from `onBehalf` for each deallocation to discourage allocation manipulations.
+ * The penalty is applied as a share burn where assets are returned to the vault, so the share price
+ * remains stable (except for rounding).
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault contract address.
+ * @param {Object} params.args - The force withdraw related parameters.
+ * @param {readonly Deallocation[]} params.args.deallocations - The list of deallocations to perform.
+ * @param {Object} params.args.withdraw - The withdraw parameters applied after deallocations.
+ * @param {bigint} params.args.withdraw.assets - The amount of assets to withdraw.
+ * @param {Address} params.args.withdraw.recipient - The recipient of the withdrawn assets.
+ * @param {Address} params.args.onBehalf - The address from which the penalty is taken (share owner).
+ * @param {Metadata} [params.metadata] - Optional analytics metadata to append.
+ * @returns {Readonly<Transaction<VaultV2ForceWithdrawAction>>} The prepared multicall transaction.
+ */
+const vaultV2ForceWithdraw = ({ vault: { address: vaultAddress }, args: { deallocations, withdraw, onBehalf }, metadata, }) => {
+    if (deallocations.length === 0) {
+        throw new types_1.EmptyDeallocationsError(vaultAddress);
+    }
+    if (withdraw.assets === 0n) {
+        throw new types_1.ZeroAssetAmountError(vaultAddress);
+    }
+    const totalDeallocated = deallocations.reduce((sum, d) => sum + d.assets, 0n);
+    if (withdraw.assets < totalDeallocated) {
+        throw new types_1.DeallocationsExceedWithdrawError(vaultAddress, withdraw.assets, totalDeallocated);
+    }
+    const calls = [];
+    for (const deallocation of deallocations) {
+        calls.push((0, encodeDeallocation_1.encodeForceDeallocateCall)(deallocation, onBehalf));
+    }
+    calls.push((0, viem_1.encodeFunctionData)({
+        abi: blue_sdk_viem_1.vaultV2Abi,
+        functionName: "withdraw",
+        args: [withdraw.assets, withdraw.recipient, onBehalf],
+    }));
+    let tx = {
+        to: vaultAddress,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: blue_sdk_viem_1.vaultV2Abi,
+            functionName: "multicall",
+            args: [calls],
+        }),
+        value: 0n,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "vaultV2ForceWithdraw",
+            args: {
+                vault: vaultAddress,
+                deallocations: deallocations.map((d) => ({ ...d })),
+                withdraw: {
+                    assets: withdraw.assets,
+                    recipient: withdraw.recipient,
+                },
+                onBehalf,
+            },
+        },
+    });
+};
+exports.vaultV2ForceWithdraw = vaultV2ForceWithdraw;

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

@@ -1,3 +1,5 @@
 export * from "./deposit";
+export * from "./forceRedeem";
+export * from "./forceWithdraw";
 export * from "./redeem";
 export * from "./withdraw";

package/lib/actions/vaultV2/index.js

@@ -15,5 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./deposit"), exports);
+__exportStar(require("./forceRedeem"), exports);
+__exportStar(require("./forceWithdraw"), exports);
 __exportStar(require("./redeem"), exports);
 __exportStar(require("./withdraw"), exports);

package/lib/entities/vaultV2/vaultV2.d.ts

@@ -1,6 +1,6 @@
 import { fetchAccrualVaultV2 } from "@morpho-org/blue-sdk-viem";
 import type { Address } from "viem";
-import { type ERC20ApprovalAction, type MorphoClientType, type Requirement, type RequirementSignature, type Transaction, type VaultV2DepositAction, type VaultV2RedeemAction, type VaultV2WithdrawAction } from "../../types";
+import { type Deallocation, type ERC20ApprovalAction, type MorphoClientType, type Requirement, type RequirementSignature, type Transaction, type VaultV2DepositAction, type VaultV2ForceRedeemAction, type VaultV2ForceWithdrawAction, type VaultV2RedeemAction, type VaultV2WithdrawAction } from "../../types";
 import type { FetchParameters } from "../../types/data";
 export interface VaultV2Actions {
     /**
@@ -72,6 +72,61 @@ export interface VaultV2Actions {
     }) => {
         buildTx: () => Readonly<Transaction<VaultV2RedeemAction>>;
     };
+    /**
+     * Prepares a force withdraw transaction for the VaultV2 contract using the vault's native multicall.
+     *
+     * This function encodes one or more on-chain forceDeallocate calls followed by a single withdraw,
+     * executed atomically via VaultV2's multicall. This allows a user to free liquidity from multiple
+     * illiquid markets and withdraw the resulting assets in one transaction.
+     *
+     * @param {Object} params - The force withdraw parameters.
+     * @param {readonly Deallocation[]} params.deallocations - The typed list of deallocations to perform.
+     * @param {Object} params.withdraw - The withdraw parameters applied after deallocations.
+     * @param {bigint} params.withdraw.assets - The amount of assets to withdraw.
+     * @param {Address} params.userAddress - User address (penalty source and withdraw recipient).
+     * @returns {Object} The result object.
+     * @returns {Readonly<Transaction<VaultV2ForceWithdrawAction>>} returns.buildTx The prepared multicall transaction.
+     */
+    forceWithdraw: (params: {
+        deallocations: readonly Deallocation[];
+        withdraw: {
+            assets: bigint;
+        };
+        userAddress: Address;
+    }) => {
+        buildTx: () => Readonly<Transaction<VaultV2ForceWithdrawAction>>;
+    };
+    /**
+     * Prepares a force redeem transaction for the VaultV2 contract using the vault's native multicall.
+     *
+     * This function encodes one or more on-chain forceDeallocate calls followed by a single redeem,
+     * executed atomically via VaultV2's multicall. This allows a user to free liquidity from multiple
+     * illiquid markets and redeem all their shares in one transaction.
+     *
+     * This is the share-based counterpart to forceWithdraw, useful for maximum withdrawal scenarios
+     * where specifying an exact asset amount is impractical.
+     *
+     * The total assets passed to forceDeallocate calls must be greater than or equal to the
+     * asset-equivalent of the redeemed shares. The caller should apply a buffer on the deallocated
+     * amounts to account for share-price drift between submission and execution.
+     *
+     * @param {Object} params - The force redeem parameters.
+     * @param {readonly Deallocation[]} params.deallocations - The typed list of deallocations to perform.
+     * @param {Object} params.redeem - The redeem parameters applied after deallocations.
+     * @param {bigint} params.redeem.shares - The amount of shares to redeem.
+     * @param {Address} params.userAddress - User address (penalty source and redeem recipient).
+     * @returns {Object} The result object.
+     * @returns {Readonly<Transaction<VaultV2ForceRedeemAction>>} returns.buildTx The prepared multicall transaction.
+     */
+    forceRedeem: (params: {
+        deallocations: readonly Deallocation[];
+        redeem: {
+            shares: bigint;
+        };
+        userAddress: Address;
+    }) => {
+        buildTx: () => Readonly<Transaction<VaultV2ForceRedeemAction>>;
+    };
 }
 export declare class MorphoVaultV2 implements VaultV2Actions {
     private readonly client;
@@ -101,4 +156,22 @@ export declare class MorphoVaultV2 implements VaultV2Actions {
     }): {
         buildTx: () => Readonly<Transaction<VaultV2RedeemAction>>;
     };
+    forceWithdraw({ deallocations, withdraw, userAddress, }: {
+        deallocations: readonly Deallocation[];
+        withdraw: {
+            assets: bigint;
+        };
+        userAddress: Address;
+    }): {
+        buildTx: () => Readonly<Transaction<VaultV2ForceWithdrawAction>>;
+    };
+    forceRedeem({ deallocations, redeem, userAddress, }: {
+        deallocations: readonly Deallocation[];
+        redeem: {
+            shares: bigint;
+        };
+        userAddress: Address;
+    }): {
+        buildTx: () => Readonly<Transaction<VaultV2ForceRedeemAction>>;
+    };
 }

package/lib/entities/vaultV2/vaultV2.js

@@ -98,5 +98,43 @@ class MorphoVaultV2 {
             }),
         };
     }
+    forceWithdraw({ deallocations, withdraw, userAddress, }) {
+        if (this.client.viemClient.chain?.id !== this.chainId) {
+            throw new types_1.ChainIdMismatchError(this.client.viemClient.chain?.id, this.chainId);
+        }
+        return {
+            buildTx: () => (0, actions_1.vaultV2ForceWithdraw)({
+                vault: { address: this.vault },
+                args: {
+                    deallocations,
+                    withdraw: {
+                        assets: withdraw.assets,
+                        recipient: userAddress,
+                    },
+                    onBehalf: userAddress,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    forceRedeem({ deallocations, redeem, userAddress, }) {
+        if (this.client.viemClient.chain?.id !== this.chainId) {
+            throw new types_1.ChainIdMismatchError(this.client.viemClient.chain?.id, this.chainId);
+        }
+        return {
+            buildTx: () => (0, actions_1.vaultV2ForceRedeem)({
+                vault: { address: this.vault },
+                args: {
+                    deallocations,
+                    redeem: {
+                        shares: redeem.shares,
+                        recipient: userAddress,
+                    },
+                    onBehalf: userAddress,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
 }
 exports.MorphoVaultV2 = MorphoVaultV2;

package/lib/helpers/encodeDeallocation.d.ts

@@ -0,0 +1,10 @@
+import { type Address, type Hex } from "viem";
+import { type Deallocation } from "../types";
+/**
+ * Encodes a single `forceDeallocate` call as ABI-encoded calldata.
+ *
+ * @param deallocation - A deallocation entry.
+ * @param onBehalf - The address from which the penalty is taken (share owner).
+ * @returns The ABI-encoded calldata for `VaultV2.forceDeallocate`.
+ */
+export declare function encodeForceDeallocateCall(deallocation: Deallocation, onBehalf: Address): Hex;

package/lib/helpers/encodeDeallocation.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeForceDeallocateCall = encodeForceDeallocateCall;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const blue_sdk_viem_1 = require("@morpho-org/blue-sdk-viem");
+const viem_1 = require("viem");
+const types_1 = require("../types");
+/**
+ * Encodes the adapter-specific `data` bytes for a `forceDeallocate` call.
+ *
+ * @param deallocation - A deallocation entry.
+ * @returns The ABI-encoded bytes to pass as `data` to VaultV2.forceDeallocate.
+ */
+function encodeDeallocateData(deallocation) {
+    if (deallocation.marketParams) {
+        return (0, viem_1.encodeAbiParameters)([blue_sdk_1.marketParamsAbi], [deallocation.marketParams]);
+    }
+    return "0x";
+}
+/**
+ * Encodes a single `forceDeallocate` call as ABI-encoded calldata.
+ *
+ * @param deallocation - A deallocation entry.
+ * @param onBehalf - The address from which the penalty is taken (share owner).
+ * @returns The ABI-encoded calldata for `VaultV2.forceDeallocate`.
+ */
+function encodeForceDeallocateCall(deallocation, onBehalf) {
+    if (deallocation.assets === 0n) {
+        throw new types_1.ZeroAssetAmountError(deallocation.adapter);
+    }
+    const data = encodeDeallocateData(deallocation);
+    return (0, viem_1.encodeFunctionData)({
+        abi: blue_sdk_viem_1.vaultV2Abi,
+        functionName: "forceDeallocate",
+        args: [deallocation.adapter, data, deallocation.assets, onBehalf],
+    });
+}

package/lib/types/action.d.ts

@@ -1,4 +1,5 @@
 import type { Address, Client, Hex } from "viem";
+import type { Deallocation } from "./deallocation";
 export interface BaseAction<TType extends string = string, TArgs extends Record<string, unknown> = Record<string, unknown>> {
     readonly type: TType;
     readonly args: TArgs;
@@ -30,7 +31,27 @@ export interface VaultV2RedeemAction extends BaseAction<"vaultV2Redeem", {
     recipient: Address;
 }> {
 }
-export type TransactionAction = ERC20ApprovalAction | VaultV2DepositAction | VaultV2WithdrawAction | VaultV2RedeemAction;
+export interface VaultV2ForceWithdrawAction extends BaseAction<"vaultV2ForceWithdraw", {
+    vault: Address;
+    deallocations: readonly Deallocation[];
+    withdraw: {
+        assets: bigint;
+        recipient: Address;
+    };
+    onBehalf: Address;
+}> {
+}
+export interface VaultV2ForceRedeemAction extends BaseAction<"vaultV2ForceRedeem", {
+    vault: Address;
+    deallocations: readonly Deallocation[];
+    redeem: {
+        shares: bigint;
+        recipient: Address;
+    };
+    onBehalf: Address;
+}> {
+}
+export type TransactionAction = ERC20ApprovalAction | VaultV2DepositAction | VaultV2WithdrawAction | VaultV2RedeemAction | VaultV2ForceWithdrawAction | VaultV2ForceRedeemAction;
 export interface Transaction<TAction extends BaseAction = TransactionAction> {
     readonly to: Address;
     readonly value: bigint;

package/lib/types/deallocation.d.ts

@@ -0,0 +1,15 @@
+import type { MarketParams } from "@morpho-org/blue-sdk";
+import type { Address } from "viem";
+/**
+ * A single deallocation entry for a `forceDeallocate` call.
+ *
+ * - When `marketParams` is provided, the adapter is treated as a Morpho Market V1 adapter
+ *   and `data` is ABI-encoded from the given `MarketParams`.
+ * - When `marketParams` is omitted, empty bytes are passed as `data` (suitable for adapters
+ *   such as Vault V1 that do not require market identification).
+ */
+export interface Deallocation {
+    readonly adapter: Address;
+    readonly marketParams?: MarketParams;
+    readonly assets: bigint;
+}

package/lib/types/deallocation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/error.d.ts

@@ -1,6 +1,6 @@
 import type { Address } from "viem";
 export declare class ZeroAssetAmountError extends Error {
-    constructor(asset: Address);
+    constructor(origin: Address);
 }
 export declare class ZeroSharesAmountError extends Error {
     constructor(vault: Address);
@@ -23,9 +23,15 @@ export declare class ApprovalAmountLessThanSpendAmountError extends Error {
 export declare class ExcessiveSlippageToleranceError extends Error {
     constructor(slippageTolerance: bigint);
 }
+export declare class EmptyDeallocationsError extends Error {
+    constructor(vault: Address);
+}
 export declare class DepositAmountMismatchError extends Error {
     constructor(depositAmount: bigint, signatureAmount: bigint);
 }
 export declare class DepositAssetMismatchError extends Error {
     constructor(depositAsset: Address, signatureAsset: Address);
 }
+export declare class DeallocationsExceedWithdrawError extends Error {
+    constructor(vault: Address, withdrawAssets: bigint, totalDeallocated: bigint);
+}

package/lib/types/error.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DepositAssetMismatchError = exports.DepositAmountMismatchError = exports.ExcessiveSlippageToleranceError = exports.ApprovalAmountLessThanSpendAmountError = exports.MissingClientPropertyError = exports.ChainIdMismatchError = exports.AddressMismatchError = exports.ZeroMaxSharePriceError = exports.ZeroSharesAmountError = exports.ZeroAssetAmountError = void 0;
+exports.DeallocationsExceedWithdrawError = exports.DepositAssetMismatchError = exports.DepositAmountMismatchError = exports.EmptyDeallocationsError = exports.ExcessiveSlippageToleranceError = exports.ApprovalAmountLessThanSpendAmountError = exports.MissingClientPropertyError = exports.ChainIdMismatchError = exports.AddressMismatchError = exports.ZeroMaxSharePriceError = exports.ZeroSharesAmountError = exports.ZeroAssetAmountError = void 0;
 class ZeroAssetAmountError extends Error {
-    constructor(asset) {
-        super(`Asset amount cannot be zero for address: ${asset}`);
+    constructor(origin) {
+        super(`Asset amount cannot be zero for address ${origin}`);
     }
 }
 exports.ZeroAssetAmountError = ZeroAssetAmountError;
@@ -49,6 +49,12 @@ class ExcessiveSlippageToleranceError extends Error {
     }
 }
 exports.ExcessiveSlippageToleranceError = ExcessiveSlippageToleranceError;
+class EmptyDeallocationsError extends Error {
+    constructor(vault) {
+        super(`Deallocations list cannot be empty for vault: ${vault}`);
+    }
+}
+exports.EmptyDeallocationsError = EmptyDeallocationsError;
 class DepositAmountMismatchError extends Error {
     constructor(depositAmount, signatureAmount) {
         super(`Deposit amount ${depositAmount} does not match requirement signature amount ${signatureAmount}`);
@@ -61,3 +67,9 @@ class DepositAssetMismatchError extends Error {
     }
 }
 exports.DepositAssetMismatchError = DepositAssetMismatchError;
+class DeallocationsExceedWithdrawError extends Error {
+    constructor(vault, withdrawAssets, totalDeallocated) {
+        super(`Total deallocated assets (${totalDeallocated}) exceed withdraw amount (${withdrawAssets}) for vault: ${vault}`);
+    }
+}
+exports.DeallocationsExceedWithdrawError = DeallocationsExceedWithdrawError;

package/lib/types/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./action";
 export * from "./client";
+export * from "./deallocation";
 export * from "./entity";
 export * from "./error";
 export * from "./metadata";

package/lib/types/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./action"), exports);
 __exportStar(require("./client"), exports);
+__exportStar(require("./deallocation"), exports);
 __exportStar(require("./entity"), exports);
 __exportStar(require("./error"), exports);
 __exportStar(require("./metadata"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@morpho-org/consumer-sdk",
   "description": "Abstraction layer for Morpho's complexity.",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "author": "Morpho Association <contact@morpho.org>",
   "contributors": [
     "Foulks-Plb <https://x.com/FoulkPlb>"
@@ -20,7 +20,7 @@
   "devDependencies": {
     "@biomejs/biome": "2.3.3",
     "@changesets/cli": "^2.29.8",
-    "@morpho-org/test": "2.6.7",
+    "@morpho-org/test": "2.7.0",
     "@types/node": "^24.9.1",
     "@vitest/coverage-v8": "3.2.4",
     "@vitest/ui": "3.2.4",