@morpho-org/consumer-sdk 0.0.1

package/README.md

@@ -0,0 +1,83 @@
+# Morpho SDK
+
+> **The abstraction layer that simplifies Morpho protocol**
+
+## ✨ How to use it? (three ways to build transactions)
+
+### 1️⃣ **With MorphoClient**
+
+```typescript
+import { MorphoClient } from "@morpho-org/consumer-sdk";
+import { createWalletClient, http } from "viem";
+
+const client = createWalletClient({
+  chain: mainnet,
+  transport: http(),
+  account: "0x...",
+});
+
+const morpho = new MorphoClient(client);
+
+const vault = morpho.vaultV2("0x1234...", 1); // vault address, chain ID
+const deposit = await vault.deposit({
+  assets: 1000000000000000000n, // vault asset amount
+  userAddress: "0x1234...", // recipient address
+});
+console.log(deposit.buildTx());
+console.log(await deposit.getRequirements());
+
+const withdraw = vault.withdraw({
+  assets: 1000000000000000000n, // vault asset amount
+  userAddress: "0x1234...", // recipient address
+});
+console.log(withdraw.buildTx());
+
+const redeem = vault.redeem({
+  shares: 1000000000000000000n, // vault shares amount
+  userAddress: "0x1234...", // recipient address
+});
+console.log(redeem.buildTx());
+```
+
+### 2️⃣ **Direct construction** (Full control)
+
+```typescript
+import { vaultV2Deposit } from "@morpho-org/consumer-sdk";
+
+const deposit = vaultV2Deposit({
+  vault: {
+    chainId: mainnet.id,
+    address: "0x1234...", // vault address
+    asset: "0x1234...", // asset address
+  },
+  args: {
+    assets: 1000000000000000000n, // vault asset amount
+    maxSharePrice: 995180497664595699494513674403n,
+    recipient: "0x1234...", // recipient address
+  },
+});
+```
+
+## Link Integration - Local Development Guide
+
+This guide explains how to link this local package to your Next.js application for easier debugging.
+
+### **Step 1: Initial setup (one time only)**
+
+```bash
+# In this consumer-sdk project
+pnpm run build:link
+```
+
+### **Step 2: In your other project**
+
+```bash
+# Link the local package
+pnpm link consumer-sdk
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Feel free to open an issue or PR.
+
+**Made with ❤️ by the Morpho team**

package/lib/actions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./requirements";
+export * from "./vaultV2";

package/lib/actions/index.js

@@ -0,0 +1,18 @@
+"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("./requirements"), exports);
+__exportStar(require("./vaultV2"), exports);

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

@@ -0,0 +1,10 @@
+import { type Address } from "@morpho-org/blue-sdk";
+import type { ERC20ApprovalAction, Transaction } from "../../types";
+interface EncodeErc20ApprovalParams {
+    token: Address;
+    spender: Address;
+    amount: bigint;
+    chainId: number;
+}
+export declare const encodeErc20Approval: (params: EncodeErc20ApprovalParams) => Transaction<ERC20ApprovalAction>;
+export {};

package/lib/actions/requirements/encodeErc20Approval.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeErc20Approval = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const simulation_sdk_1 = require("@morpho-org/simulation-sdk");
+const viem_1 = require("viem");
+const encodeErc20Approval = (params) => {
+    const { token, spender, amount, chainId } = params;
+    const amountValue = blue_sdk_1.MathLib.min(amount, simulation_sdk_1.MAX_TOKEN_APPROVALS[chainId]?.[token] ?? viem_1.maxUint256);
+    return (0, morpho_ts_1.deepFreeze)({
+        to: token,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: viem_1.erc20Abi,
+            functionName: "approve",
+            args: [spender, amountValue],
+        }),
+        value: 0n,
+        action: {
+            type: "erc20Approval",
+            args: { spender: spender, amount: amountValue },
+        },
+    });
+};
+exports.encodeErc20Approval = encodeErc20Approval;

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

@@ -0,0 +1,11 @@
+import { type Address } from "@morpho-org/blue-sdk";
+import type { Client } from "viem";
+import { type ERC20ApprovalAction, type Transaction } from "../../types";
+export declare const getRequirements: (viemClient: Client, params: {
+    address: Address;
+    chainId: number;
+    args: {
+        amount: bigint;
+        from: Address;
+    };
+}) => Promise<Readonly<Transaction<ERC20ApprovalAction>[]>>;

package/lib/actions/requirements/getRequirements.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRequirements = 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 simulation_sdk_1 = require("@morpho-org/simulation-sdk");
+const types_1 = require("../../types");
+const encodeErc20Approval_1 = require("./encodeErc20Approval");
+const getRequirements = async (viemClient, params) => {
+    const { address, chainId, args: { amount, from }, } = params;
+    if (viemClient.chain?.id !== chainId) {
+        throw new types_1.ChainIdMismatchError(viemClient.chain?.id, chainId);
+    }
+    const { bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    const { erc20Allowances } = await (0, blue_sdk_viem_1.fetchHolding)(from, address, viemClient);
+    const txs = [];
+    if (erc20Allowances["bundler3.generalAdapter1"] < amount) {
+        if (simulation_sdk_1.APPROVE_ONLY_ONCE_TOKENS[chainId]?.includes(address) &&
+            erc20Allowances["bundler3.generalAdapter1"] > 0n) {
+            txs.push((0, encodeErc20Approval_1.encodeErc20Approval)({
+                token: address,
+                spender: generalAdapter1,
+                amount: 0n,
+                chainId,
+            }));
+        }
+        txs.push((0, encodeErc20Approval_1.encodeErc20Approval)({
+            token: address,
+            spender: generalAdapter1,
+            amount,
+            chainId,
+        }));
+    }
+    return (0, morpho_ts_1.deepFreeze)(txs);
+};
+exports.getRequirements = getRequirements;

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

@@ -0,0 +1,2 @@
+export * from "./encodeErc20Approval";
+export * from "./getRequirements";

package/lib/actions/requirements/index.js

@@ -0,0 +1,18 @@
+"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("./encodeErc20Approval"), exports);
+__exportStar(require("./getRequirements"), exports);

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

@@ -0,0 +1,42 @@
+import type { Address } from "viem";
+import { type Metadata, type Transaction, type VaultV2DepositAction } from "../../types";
+export interface VaultV2DepositParams {
+    vault: {
+        chainId: number;
+        address: Address;
+        asset: Address;
+    };
+    args: {
+        assets: bigint;
+        maxSharePrice: bigint;
+        recipient: Address;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a deposit transaction for the VaultV2 contract.
+ *
+ * This function constructs the transaction data required to deposit a specified amount of assets into the vault.
+ * Bundler Integration: This flow uses the bundler to atomically execute the user's asset transfer and vault deposit in a single transaction for slippage protection.
+ *
+ * IMPORTANT FOR DEVELOPERS:
+ * This deposit flow is routed through the general adapter in order to enforce a strict check on `maxSharePrice`.
+ * This check is critical to prevent inflation attacks, especially for vaults where there is no "dead deposit" protection.
+ * Do not bypass the general adapter or remove this check, as doing so would expose the flow to potential exploits.
+ * The maxSharePrice constraint ensures that the user does not receive unfavorable share pricing due to malicious or sudden vault changes.
+ *
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {number} params.vault.chainId - The chain ID.
+ * @param {Address} params.vault.address - The vault address.
+ * @param {Address} params.vault.asset - The vault asset address.
+ * @param {Object} params.args - The deposit related parameters.
+ * @param {bigint} params.args.assets - The amount of assets to deposit.
+ * @param {bigint} params.args.maxSharePrice - The maximum share price to accept for the deposit.
+ * @param {Address} params.args.recipient - The recipient address.
+ * @param {Metadata} [params.metadata] - Optional the metadata.
+ *
+ * @returns {Readonly<Transaction<VaultV2DepositAction>>} The prepared deposit transaction.
+ */
+export declare const vaultV2Deposit: ({ vault: { chainId, address: vaultAddress, asset }, args: { assets, maxSharePrice, recipient }, metadata, }: VaultV2DepositParams) => Readonly<Transaction<VaultV2DepositAction>>;

package/lib/actions/vaultV2/deposit.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultV2Deposit = 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");
+/**
+ * Prepares a deposit transaction for the VaultV2 contract.
+ *
+ * This function constructs the transaction data required to deposit a specified amount of assets into the vault.
+ * Bundler Integration: This flow uses the bundler to atomically execute the user's asset transfer and vault deposit in a single transaction for slippage protection.
+ *
+ * IMPORTANT FOR DEVELOPERS:
+ * This deposit flow is routed through the general adapter in order to enforce a strict check on `maxSharePrice`.
+ * This check is critical to prevent inflation attacks, especially for vaults where there is no "dead deposit" protection.
+ * Do not bypass the general adapter or remove this check, as doing so would expose the flow to potential exploits.
+ * The maxSharePrice constraint ensures that the user does not receive unfavorable share pricing due to malicious or sudden vault changes.
+ *
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {number} params.vault.chainId - The chain ID.
+ * @param {Address} params.vault.address - The vault address.
+ * @param {Address} params.vault.asset - The vault asset address.
+ * @param {Object} params.args - The deposit related parameters.
+ * @param {bigint} params.args.assets - The amount of assets to deposit.
+ * @param {bigint} params.args.maxSharePrice - The maximum share price to accept for the deposit.
+ * @param {Address} params.args.recipient - The recipient address.
+ * @param {Metadata} [params.metadata] - Optional the metadata.
+ *
+ * @returns {Readonly<Transaction<VaultV2DepositAction>>} The prepared deposit transaction.
+ */
+const vaultV2Deposit = ({ vault: { chainId, address: vaultAddress, asset }, args: { assets, maxSharePrice, recipient }, metadata, }) => {
+    if (assets === 0n) {
+        throw new types_1.ZeroAssetAmountError(asset);
+    }
+    if (maxSharePrice === 0n) {
+        throw new types_1.ZeroMaxSharePriceError(vaultAddress);
+    }
+    const { bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    const actions = [
+        {
+            type: "erc20TransferFrom",
+            args: [asset, assets, generalAdapter1, false],
+        },
+        {
+            type: "erc4626Deposit",
+            args: [vaultAddress, assets, maxSharePrice, recipient, false],
+        },
+    ];
+    let tx = bundler_sdk_viem_1.BundlerAction.encodeBundle(chainId, actions);
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "vaultV2Deposit",
+            args: { vault: vaultAddress, assets, maxSharePrice, recipient },
+        },
+    });
+};
+exports.vaultV2Deposit = vaultV2Deposit;

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

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

package/lib/actions/vaultV2/index.js

@@ -0,0 +1,19 @@
+"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("./deposit"), exports);
+__exportStar(require("./redeem"), exports);
+__exportStar(require("./withdraw"), exports);

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

@@ -0,0 +1,32 @@
+import { type Address } from "viem";
+import { type Metadata, type Transaction, type VaultV2RedeemAction } from "../../types";
+export interface VaultV2RedeemParams {
+    vault: {
+        address: Address;
+    };
+    args: {
+        shares: bigint;
+        recipient: Address;
+        onBehalf: Address;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a redeem transaction for the VaultV2 contract.
+ *
+ * This function constructs the transaction data required to redeem a specified amount of shares from the vault.
+ *
+ * IMPORTANT FOR DEVELOPERS:
+ * This flow is not routed through the bundler because the risks are negligible since these operations cannot be affected by attacks. This avoids unnecessary approvals and keeps the UX clean.
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault address.
+ * @param {Object} params.args - The redeem related parameters.
+ * @param {bigint} params.args.shares - The amount of shares to redeem.
+ * @param {Address} params.args.recipient - The recipient address.
+ * @param {Address} params.args.onBehalf - The address on behalf of which the redeem is made.
+ * @param {Metadata} [params.metadata] - Optional the metadata.
+ * @returns {Readonly<Transaction<VaultV2RedeemAction>>} The prepared redeem transaction.
+ */
+export declare const vaultV2Redeem: ({ vault: { address: vaultAddress }, args: { shares, recipient, onBehalf }, metadata, }: VaultV2RedeemParams) => Readonly<Transaction<VaultV2RedeemAction>>;

package/lib/actions/vaultV2/redeem.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultV2Redeem = 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 types_1 = require("../../types");
+/**
+ * Prepares a redeem transaction for the VaultV2 contract.
+ *
+ * This function constructs the transaction data required to redeem a specified amount of shares from the vault.
+ *
+ * IMPORTANT FOR DEVELOPERS:
+ * This flow is not routed through the bundler because the risks are negligible since these operations cannot be affected by attacks. This avoids unnecessary approvals and keeps the UX clean.
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault address.
+ * @param {Object} params.args - The redeem related parameters.
+ * @param {bigint} params.args.shares - The amount of shares to redeem.
+ * @param {Address} params.args.recipient - The recipient address.
+ * @param {Address} params.args.onBehalf - The address on behalf of which the redeem is made.
+ * @param {Metadata} [params.metadata] - Optional the metadata.
+ * @returns {Readonly<Transaction<VaultV2RedeemAction>>} The prepared redeem transaction.
+ */
+const vaultV2Redeem = ({ vault: { address: vaultAddress }, args: { shares, recipient, onBehalf }, metadata, }) => {
+    if (shares === 0n) {
+        throw new types_1.ZeroSharesAmountError(vaultAddress);
+    }
+    let tx = {
+        to: vaultAddress,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: blue_sdk_viem_1.vaultV2Abi,
+            functionName: "redeem",
+            args: [shares, recipient, onBehalf],
+        }),
+        value: 0n,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "vaultV2Redeem",
+            args: { vault: vaultAddress, shares, recipient },
+        },
+    });
+};
+exports.vaultV2Redeem = vaultV2Redeem;

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

@@ -0,0 +1,32 @@
+import { type Address } from "viem";
+import { type Metadata, type Transaction, type VaultV2WithdrawAction } from "../../types";
+export interface VaultV2WithdrawParams {
+    vault: {
+        address: Address;
+    };
+    args: {
+        assets: bigint;
+        recipient: Address;
+        onBehalf: Address;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a withdraw transaction for the VaultV2 contract.
+ *
+ * This function constructs the transaction data required to withdraw a specified amount of assets from the vault.
+ *
+ * IMPORTANT FOR DEVELOPERS:
+ * This flow is not routed through the bundler because the risks are negligible since these operations cannot be affected by attacks. This avoids unnecessary approvals and keeps the UX clean.
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault address.
+ * @param {Object} params.args - The withdraw related parameters.
+ * @param {bigint} params.args.assets - The amount of assets to withdraw.
+ * @param {Address} params.args.recipient - The recipient address.
+ * @param {Address} params.args.onBehalf - The address on behalf of which the withdraw is made.
+ * @param {Metadata} [params.metadata] - Optional the metadata.
+ * @returns {Readonly<Transaction<VaultV2WithdrawAction>>} The prepared withdraw transaction.
+ */
+export declare const vaultV2Withdraw: ({ vault: { address: vaultAddress }, args: { assets, recipient, onBehalf }, metadata, }: VaultV2WithdrawParams) => Readonly<Transaction<VaultV2WithdrawAction>>;

package/lib/actions/vaultV2/withdraw.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultV2Withdraw = 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 types_1 = require("../../types");
+/**
+ * Prepares a withdraw transaction for the VaultV2 contract.
+ *
+ * This function constructs the transaction data required to withdraw a specified amount of assets from the vault.
+ *
+ * IMPORTANT FOR DEVELOPERS:
+ * This flow is not routed through the bundler because the risks are negligible since these operations cannot be affected by attacks. This avoids unnecessary approvals and keeps the UX clean.
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault address.
+ * @param {Object} params.args - The withdraw related parameters.
+ * @param {bigint} params.args.assets - The amount of assets to withdraw.
+ * @param {Address} params.args.recipient - The recipient address.
+ * @param {Address} params.args.onBehalf - The address on behalf of which the withdraw is made.
+ * @param {Metadata} [params.metadata] - Optional the metadata.
+ * @returns {Readonly<Transaction<VaultV2WithdrawAction>>} The prepared withdraw transaction.
+ */
+const vaultV2Withdraw = ({ vault: { address: vaultAddress }, args: { assets, recipient, onBehalf }, metadata, }) => {
+    if (assets === 0n) {
+        throw new types_1.ZeroAssetAmountError(vaultAddress);
+    }
+    let tx = {
+        to: vaultAddress,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: blue_sdk_viem_1.vaultV2Abi,
+            functionName: "withdraw",
+            args: [assets, recipient, onBehalf],
+        }),
+        value: 0n,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "vaultV2Withdraw",
+            args: { vault: vaultAddress, assets, recipient },
+        },
+    });
+};
+exports.vaultV2Withdraw = vaultV2Withdraw;

package/lib/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./morphoClient";
+export * from "./morphoViemExtension";

package/lib/client/index.js

@@ -0,0 +1,18 @@
+"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("./morphoClient"), exports);
+__exportStar(require("./morphoViemExtension"), exports);

package/lib/client/morphoClient.d.ts

@@ -0,0 +1,9 @@
+import type { Address, Client } from "viem";
+import { MorphoVaultV2 } from "../entities";
+import type { Metadata, MorphoClientType } from "../types";
+export declare class MorphoClient implements MorphoClientType {
+    readonly viemClient: Client;
+    readonly metadata?: Metadata | undefined;
+    constructor(viemClient: Client, metadata?: Metadata | undefined);
+    vaultV2(vault: Address, chainId: number): MorphoVaultV2;
+}

package/lib/client/morphoClient.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MorphoClient = void 0;
+const entities_1 = require("../entities");
+class MorphoClient {
+    viemClient;
+    metadata;
+    constructor(viemClient, metadata) {
+        this.viemClient = viemClient;
+        this.metadata = metadata;
+    }
+    vaultV2(vault, chainId) {
+        return new entities_1.MorphoVaultV2(this, vault, chainId);
+    }
+}
+exports.MorphoClient = MorphoClient;

package/lib/client/morphoViemExtension.d.ts

@@ -0,0 +1,30 @@
+import type { Client } from "viem";
+import type { Metadata } from "../types";
+import { MorphoClient } from "./morphoClient";
+/**
+ * Morpho extension for viem clients.
+ * Adds `morpho` namespace to viem clients with vaultV2 actions.
+ *
+ * @param metadata - (Optional) Metadata object that will be passed to all morpho actions. If provided, this metadata can be used for analytics, logging, or to carry additional information with each action.
+ * @returns Extension function that adds morpho namespace to viem clients
+ *
+ * @example
+ * ```ts
+ * import { createWalletClient, http } from 'viem';
+ * import { mainnet } from 'viem/chains';
+ * import { morpho } from 'consumer-sdk';
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ *   account: '0x...',
+ * }).extend(morphoViemExtension());
+ *
+ * // Use morpho actions
+ * const vault = client.morpho.vaultV2('0x...');
+ * const deposit = await vault.deposit({ assets: 1000000000000000000n });
+ * ```
+ */
+export declare function morphoViemExtension(metadata?: Metadata): <TClient extends Client>(client: TClient) => {
+    morpho: MorphoClient;
+};

package/lib/client/morphoViemExtension.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.morphoViemExtension = morphoViemExtension;
+const morphoClient_1 = require("./morphoClient");
+/**
+ * Morpho extension for viem clients.
+ * Adds `morpho` namespace to viem clients with vaultV2 actions.
+ *
+ * @param metadata - (Optional) Metadata object that will be passed to all morpho actions. If provided, this metadata can be used for analytics, logging, or to carry additional information with each action.
+ * @returns Extension function that adds morpho namespace to viem clients
+ *
+ * @example
+ * ```ts
+ * import { createWalletClient, http } from 'viem';
+ * import { mainnet } from 'viem/chains';
+ * import { morpho } from 'consumer-sdk';
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ *   account: '0x...',
+ * }).extend(morphoViemExtension());
+ *
+ * // Use morpho actions
+ * const vault = client.morpho.vaultV2('0x...');
+ * const deposit = await vault.deposit({ assets: 1000000000000000000n });
+ * ```
+ */
+function morphoViemExtension(metadata) {
+    return (client) => {
+        return {
+            morpho: new morphoClient_1.MorphoClient(client, metadata),
+        };
+    };
+}

package/lib/entities/index.d.ts

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