0xtrails 0.2.5 → 0.3.0

package/src/intents.ts

@@ -1,19 +1,21 @@
 import type {
-  CommitIntentConfigArgs,
-  CommitIntentConfigReturn,
-  GetIntentCallsPayloadsArgs,
-  GetIntentCallsPayloadsReturn,
-  IntentCallsPayload,
-  IntentPrecondition,
+  QuoteIntentRequest,
+  CommitIntentResponse,
+  Intent,
+  IntentCalls,
+  TransactionPrecondition,
+  TrailsAPIClient,
+  ExecuteIntentRequest,
+  GasFeeOptions,
+  DepositSignature,
 } from "@0xsequence/trails-api"
-import type { TrailsAPIClient } from "@0xsequence/trails-api"
 import type { TrailsClient } from "./trailsClient.js"
 import { logger } from "./logger.js"
 import { bigintReplacer } from "./utils.js"
 
 export type {
-  IntentCallsPayload,
-  IntentPrecondition,
+  IntentCalls,
+  TransactionPrecondition,
 } from "@0xsequence/trails-api"
 
 import { Config, type Context, Payload } from "@0xsequence/wallet-primitives"
@@ -36,7 +38,6 @@ import {
 import {
   ATTESATION_SIGNER_ADDRESS,
   SEQUENCE_V3_CONTRACT_ADDRESSES,
-  SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES,
 } from "./constants.js"
 import { findPreconditionAddresses } from "./preconditions.js"
 import { getChainInfo } from "./chains.js"
@@ -114,7 +115,7 @@ export interface TrailsFee {
 // QuoteProvider defines the possible liquidity providers.
 export type QuoteProvider = "lifi" | "relay" | "cctp"
 
-export type { GetIntentCallsPayloadsReturn }
+export type { Intent }
 
 export type OriginCallParams = {
   to: `0x${string}` | null
@@ -135,98 +136,104 @@ export type SendOriginCallTxArgs = {
 }
 
 export async function getLocalClientIfEnabled(
-  apiClient: TrailsAPIClient,
+  trailsClient: TrailsAPIClient,
 ): Promise<TrailsAPIClient> {
   const localApiIntent = getQueryParam("localapiintent") === "true"
   if (localApiIntent) {
     // for testing local api changes
     const { getTrailsClient } = await import("./trailsClient.js")
-    apiClient = getTrailsClient({
+    trailsClient = getTrailsClient({
       hostname: "http://localhost:4422",
     })
   }
-  return apiClient
+  return trailsClient
 }
 
-export async function getIntentCallsPayloads(
-  apiClient: TrailsAPIClient,
-  args: GetIntentCallsPayloadsArgs,
+export async function getIntent(
+  trailsClient: TrailsAPIClient,
+  args: QuoteIntentRequest,
   additionalTrackingProps: Record<string, string> = {},
-): Promise<GetIntentCallsPayloadsReturn> {
-  apiClient = await getLocalClientIfEnabled(apiClient)
+): Promise<{ intent: Intent; gasFeeOptions?: GasFeeOptions }> {
+  trailsClient = await getLocalClientIfEnabled(trailsClient)
 
   // Track intent quote request
   trackIntentQuoteRequested({
-    originChainId: args.params.originChainId || 0,
-    destinationChainId: args.params.destinationChainId || 0,
-    originTokenAddress: args.params.originTokenAddress,
-    destinationTokenAddress: args.params.destinationTokenAddress,
-    userAddress: args.params.userAddress,
+    originChainId: args.originChainId || 0,
+    destinationChainId: args.destinationChainId || 0,
+    originTokenAddress: args.originTokenAddress,
+    destinationTokenAddress: args.destinationTokenAddress,
+    userAddress: args.ownerAddress,
     ...additionalTrackingProps,
   })
 
   try {
-    logger.console.log("[trails-sdk] getIntentCallsPayloads args:", args)
-    const result = await apiClient.getIntentCallsPayloads({
-      params: args.params,
-    })
+    logger.console.log("[trails-sdk] getIntent args:", args)
+    const response = await trailsClient.quoteIntent(args)
 
-    if (!result) {
-      logger.console.error("[trails-sdk] No result from getIntentCallsPayloads")
-      throw new Error("No result from getIntentCallsPayloads")
+    if (!response || !response.intent) {
+      logger.console.error("[trails-sdk] No result from quoteIntent")
+      throw new Error("No result from quoteIntent")
     }
 
+    const result = response.intent
+
     // Extract precondition amounts
-    const originChainId = args.params.originChainId || 0
-    const destinationChainId = args.params.destinationChainId || 0
-    const originPrecondition = result.payloads.preconditions?.find(
-      (p: IntentPrecondition) => Number(p.chainId) === Number(originChainId),
+    const originChainId = args.originChainId || 0
+    const destinationChainId = args.destinationChainId || 0
+    const originPrecondition = result.preconditions?.find(
+      (p: TransactionPrecondition) =>
+        Number(p.chainId) === Number(originChainId),
     )
-    const destinationPrecondition = result.payloads.preconditions?.find(
-      (p: IntentPrecondition) =>
+    const destinationPrecondition = result.preconditions?.find(
+      (p: TransactionPrecondition) =>
         Number(p.chainId) === Number(destinationChainId),
     )
 
     // Track successful intent quote received
     trackIntentQuoteReceived({
-      quoteId: result.payloads.originIntentAddress || "unknown",
-      totalFeeUSD: result.payloads.trailsFee?.totalFeeUSD,
-      crossChainFeeTotalUSD:
-        result.payloads.trailsFee?.crossChainFee?.totalFeeUSD,
-      providerFeeUSD: result.payloads.trailsFee?.crossChainFee?.providerFeeUSD,
-      trailsSwapFeeUSD:
-        result.payloads.trailsFee?.crossChainFee?.trailsSwapFeeUSD,
-      gasFeesPerChainUSD:
-        result.payloads.trailsFee?.executeQuote?.chainQuotes?.map(
-          (quote: any) => parseFloat(quote.totalFeeUSD || "0"),
-        ) || [],
-      originTokenTotalAmount: result.payloads.trailsFee?.originTokenTotalAmount,
-      totalFeeAmount: result.payloads.trailsFee?.totalFeeAmount, // Using available property
-      provider: result.payloads.trailsFee?.quoteProvider,
-      feeToken: result.payloads.trailsFee?.feeToken,
-      userAddress: args.params.userAddress,
-      intentAddress: result.payloads.originIntentAddress,
-      originPreconditionAmount: originPrecondition?.data?.min?.toString(),
+      quoteId: result.originIntentAddress || "unknown",
+      totalFeeUSD: result.fees?.totalFeeUsd?.toString(),
+      crossChainFeeTotalUSD: result.fees?.provider?.totalFeeUsd,
+      providerFeeUSD: result.fees?.provider?.quoteProviderFeeUsd,
+      trailsSwapFeeUSD: result.fees?.provider?.trailsFeeUsd,
+      gasFeesPerChainUSD: [
+        typeof result.fees?.originGas?.totalFeeUsd === "string"
+          ? parseFloat(result.fees.originGas.totalFeeUsd)
+          : result.fees?.originGas?.totalFeeUsd || 0,
+        typeof result.fees?.destinationGas?.totalFeeUsd === "string"
+          ? parseFloat(result.fees.destinationGas.totalFeeUsd)
+          : result.fees?.destinationGas?.totalFeeUsd || 0,
+      ],
+      originTokenTotalAmount: undefined, // This field no longer exists in IntentFees
+      totalFeeAmount: result.fees?.totalFeeAmount?.toString(),
+      provider: result.quote?.quoteProvider,
+      feeToken: result.fees?.feeTokenAddress,
+      userAddress: args.ownerAddress,
+      intentAddress: result.originIntentAddress,
+      originPreconditionAmount: originPrecondition?.minAmount?.toString(),
       destinationPreconditionAmount:
-        destinationPrecondition?.data?.min?.toString(),
-      fromAmount: result.payloads.quote?.fromAmount,
-      fromAmountMin: result.payloads.quote?.fromAmountMin,
-      toAmount: result.payloads.quote?.toAmount,
-      toAmountMin: result.payloads.quote?.toAmountMin,
+        destinationPrecondition?.minAmount?.toString(),
+      fromAmount: result.quote?.fromAmount?.toString(),
+      fromAmountMin: result.quote?.fromAmountMin?.toString(),
+      toAmount: result.quote?.toAmount?.toString(),
+      toAmountMin: result.quote?.toAmountMin?.toString(),
       ...additionalTrackingProps,
     })
 
-    return result
+    return {
+      intent: result,
+      gasFeeOptions: response.gasFeeOptions,
+    }
   } catch (error) {
-    logger.console.error("[trails-sdk] Error in getIntentCallsPayloads", error)
+    logger.console.error("[trails-sdk] Error in getIntent", error)
     // Track intent quote error
     trackIntentQuoteError({
       error: getFullErrorMessage(error),
-      userAddress: args.params.userAddress,
-      originChainId: args.params.originChainId || 0,
-      destinationChainId: args.params.destinationChainId || 0,
-      originTokenAddress: args.params.originTokenAddress,
-      destinationTokenAddress: args.params.destinationTokenAddress,
+      userAddress: args.ownerAddress,
+      originChainId: args.originChainId || 0,
+      destinationChainId: args.destinationChainId || 0,
+      originTokenAddress: args.originTokenAddress,
+      destinationTokenAddress: args.destinationTokenAddress,
       ...additionalTrackingProps,
     })
     throw error
@@ -235,7 +242,7 @@ export async function getIntentCallsPayloads(
 
 export function calculateIntentAddress(
   mainSigner: string,
-  calls: Array<IntentCallsPayload>,
+  calls: Array<IntentCalls>,
 ): `0x${string}` {
   logger.console.log("[trails-sdk] calculateIntentAddress inputs:", {
     mainSigner,
@@ -244,25 +251,52 @@ export function calculateIntentAddress(
 
   const context = SEQUENCE_V3_CONTRACT_ADDRESSES
 
-  const coreCalls = calls.map((call) => ({
-    type: "call" as const,
-    chainId: call.chainId.toString(),
-    space: call.space ? call.space.toString() : "0",
-    nonce: call.nonce ? call.nonce.toString() : "0",
-    calls: call.calls.map((call) => ({
-      to: Address.from(call.to) as `0x${string}`,
-      value: call.value?.toString() || "0",
-      data: Bytes.toHex(Bytes.from((call.data as Hex.Hex) || "0x")),
-      gasLimit: call.gasLimit?.toString() || "0",
-      delegateCall: !!call.delegateCall,
-      onlyFallback: !!call.onlyFallback,
-      behaviorOnError: call.behaviorOnError,
-    })),
-  }))
+  const coreCalls = calls.map((call) => {
+    const chainId =
+      typeof call.chainId === "bigint"
+        ? call.chainId
+        : BigInt(String(call.chainId))
+    const space = call.space
+      ? typeof call.space === "bigint"
+        ? call.space
+        : BigInt(String(call.space))
+      : 0n
+    const nonce = call.nonce
+      ? typeof call.nonce === "bigint"
+        ? call.nonce
+        : BigInt(String(call.nonce))
+      : 0n
+
+    return {
+      type: "call" as const,
+      chainId,
+      space,
+      nonce,
+      calls: call.calls.map((call) => ({
+        to: Address.from(call.to) as `0x${string}`,
+        value:
+          typeof call.value === "bigint"
+            ? call.value
+            : call.value
+              ? BigInt(String(call.value))
+              : 0n,
+        data: Bytes.toHex(Bytes.from((call.data as Hex.Hex) || "0x")),
+        gasLimit:
+          typeof call.gasLimit === "bigint"
+            ? call.gasLimit
+            : call.gasLimit
+              ? BigInt(String(call.gasLimit))
+              : 0n,
+        delegateCall: !!call.delegateCall,
+        onlyFallback: !!call.onlyFallback,
+        behaviorOnError: call.behaviorOnError,
+      })),
+    }
+  })
 
   const calculatedAddress = calculateIntentConfigurationAddress(
     Address.from(mainSigner),
-    coreCalls,
+    coreCalls as any, // Type mismatch between local bigint and API number for chainId
     context,
   )
 
@@ -275,7 +309,7 @@ export function calculateIntentAddress(
 
 export function calculateOriginAndDestinationIntentAddresses(
   mainSigner: string,
-  calls: Array<IntentCallsPayload>,
+  calls: Array<IntentCalls>,
 ) {
   const originChainId = calls[0]?.chainId
   const destinationChainId = calls[1]?.chainId || originChainId
@@ -292,7 +326,11 @@ export function calculateOriginAndDestinationIntentAddresses(
 
   const originIntentAddress = calculateIntentAddress(mainSigner, originCalls)
   let destinationIntentAddress = originIntentAddress
-  if (originChainId !== destinationChainId) {
+
+  // Calculate separate destination intent address if:
+  // 1. Cross-chain scenario (different chain IDs), OR
+  // 2. Same-chain with multiple payloads (e.g., custom calldata creates separate origin/destination payloads)
+  if (originChainId !== destinationChainId || calls.length > 1) {
     destinationIntentAddress = calculateIntentAddress(
       mainSigner,
       destinationCalls,
@@ -308,55 +346,56 @@ export function calculateOriginAndDestinationIntentAddresses(
   return { originIntentAddress, destinationIntentAddress }
 }
 
-export async function commitIntentConfig(
-  apiClient: TrailsClient,
-  mainSignerAddress: string,
-  calls: Array<IntentCallsPayload>,
-  preconditions: Array<IntentPrecondition>,
+export async function commitIntent(
+  trailsClient: TrailsClient,
+  intent: Intent,
   additionalTrackingProps: Record<string, string> = {},
-  requestParams?: IntentRequestParams,
-): Promise<CommitIntentConfigReturn> {
-  apiClient = await getLocalClientIfEnabled(apiClient)
-
-  logger.console.log("[trails-sdk] commitIntentConfig inputs:", {
-    mainSignerAddress,
-    calls: JSON.stringify(calls, bigintReplacer, 2),
-    preconditions: JSON.stringify(preconditions, bigintReplacer, 2),
-    requestParams: JSON.stringify(requestParams, bigintReplacer, 2),
+): Promise<CommitIntentResponse> {
+  trailsClient = await getLocalClientIfEnabled(trailsClient)
+
+  logger.console.log("[trails-sdk] commitIntent inputs:", {
+    intentId: intent.intentId,
+    ownerAddress: intent.ownerAddress,
+    originIntentAddress: intent.originIntentAddress,
+    destinationIntentAddress: intent.destinationIntentAddress,
+    calls: JSON.stringify(intent.calls, bigintReplacer, 2),
+    preconditions: JSON.stringify(intent.preconditions, bigintReplacer, 2),
   })
 
   // Additional detailed precondition logging
-  logger.console.log("[trails-sdk] Detailed preconditions:", preconditions)
+  logger.console.log(
+    "[trails-sdk] Detailed preconditions:",
+    intent.preconditions,
+  )
 
   // Log each precondition individually for easier reading
-  preconditions.forEach((precondition, index) => {
+  intent.preconditions.forEach((precondition, index) => {
     logger.console.log(`[trails-sdk] Precondition ${index}:`, {
       type: precondition.type,
       chainId: precondition.chainId,
-      data: precondition.data,
+      ownerAddress: precondition.ownerAddress,
+      tokenAddress: precondition.tokenAddress,
+      minAmount: precondition.minAmount?.toString(),
     })
   })
 
-  const { originIntentAddress, destinationIntentAddress } =
-    calculateOriginAndDestinationIntentAddresses(mainSignerAddress, calls)
-
   logger.console.log(
     "[trails-sdk] originIntentAddress:",
-    originIntentAddress.toString(),
+    intent.originIntentAddress,
   )
   logger.console.log(
     "[trails-sdk] destinationIntentAddress:",
-    destinationIntentAddress.toString(),
+    intent.destinationIntentAddress,
   )
 
-  const originChainIdStr = calls[0]?.chainId
-  const destinationChainIdStr = calls[1]?.chainId
+  const originChainIdStr = intent.calls[0]?.chainId
+  const destinationChainIdStr = intent.calls[1]?.chainId
 
   // The executionInfos could be empty, so we need to handle the undefined case.
   const { originAddress: receivedAddress } =
     originChainIdStr && destinationChainIdStr
       ? findPreconditionAddresses(
-          preconditions,
+          intent.preconditions,
           Number(originChainIdStr),
           Number(destinationChainIdStr),
         )
@@ -364,60 +403,20 @@ export async function commitIntentConfig(
 
   logger.console.log("[trails-sdk] Address comparison:", {
     receivedAddress,
-    calculatedAddress: originIntentAddress.toString(),
+    calculatedAddress: intent.originIntentAddress,
     match:
       receivedAddress &&
-      isAddressEqual(Address.from(receivedAddress), originIntentAddress),
+      isAddressEqual(
+        Address.from(receivedAddress),
+        Address.from(intent.originIntentAddress),
+      ),
   })
 
-  const addressOverrides = SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES
-
-  const args: CommitIntentConfigArgs = {
-    params: {
-      originIntentAddress: originIntentAddress.toString(),
-      destinationIntentAddress: destinationIntentAddress.toString(),
-      mainSigner: mainSignerAddress,
-      calls: calls,
-      preconditions: preconditions,
-      addressOverrides: addressOverrides,
-      requestParams: {
-        version: "1.0",
-        ...requestParams,
-      } as any,
-    },
-  }
-
-  // Add request parameters if provided
-  if (requestParams) {
-    // Convert requestParams to the format expected by the backend
-    const requestParamsForStorage = {
-      version: "1.0",
-      userAddress: requestParams.userAddress,
-      originChainId: requestParams.originChainId,
-      originTokenAddress: requestParams.originTokenAddress,
-      originTokenAmount: requestParams.originTokenAmount,
-      destinationChainId: requestParams.destinationChainId,
-      destinationToAddress: requestParams.destinationToAddress,
-      destinationTokenAddress: requestParams.destinationTokenAddress,
-      destinationTokenAmount: requestParams.destinationTokenAmount,
-      destinationCallData: requestParams.destinationCallData,
-      destinationCallValue: requestParams.destinationCallValue,
-      createdAt: new Date().toISOString(),
-    }
-    // Store request params in a way that can be passed to the API
-    logger.console.log(
-      "[trails-sdk] Request params for storage:",
-      requestParamsForStorage,
-    )
-    // Note: The current API client doesn't support request params yet
-    // This will need to be updated when the API client is regenerated
-  }
-
   try {
-    // Track successful intent commit
+    // Track intent commit start
     trackIntentCommitStarted({
-      intentAddress: originIntentAddress.toString(),
-      userAddress: mainSignerAddress,
+      intentAddress: intent.originIntentAddress,
+      userAddress: intent.ownerAddress,
       originChainId: originChainIdStr ? Number(originChainIdStr) : undefined,
       destinationChainId: destinationChainIdStr
         ? Number(destinationChainIdStr)
@@ -425,14 +424,13 @@ export async function commitIntentConfig(
       ...additionalTrackingProps,
     })
 
-    const result = await apiClient.commitIntentConfig({
-      ...args,
-    })
+    // Commit the intent that was returned from quoteIntent
+    const response = await trailsClient.commitIntent({ intent })
 
     // Track successful intent commit
     trackIntentCommitCompleted({
-      intentAddress: originIntentAddress.toString(),
-      userAddress: mainSignerAddress,
+      intentAddress: intent.originIntentAddress,
+      userAddress: intent.ownerAddress,
       originChainId: originChainIdStr ? Number(originChainIdStr) : undefined,
       destinationChainId: destinationChainIdStr
         ? Number(destinationChainIdStr)
@@ -440,13 +438,13 @@ export async function commitIntentConfig(
       ...additionalTrackingProps,
     })
 
-    return result
+    return response
   } catch (error) {
     // Track intent commit error
     trackIntentCommitError({
       error: getFullErrorMessage(error),
-      userAddress: mainSignerAddress,
-      intentAddress: originIntentAddress.toString(),
+      userAddress: intent.ownerAddress,
+      intentAddress: intent.originIntentAddress,
       originChainId: originChainIdStr ? Number(originChainIdStr) : undefined,
       destinationChainId: destinationChainIdStr
         ? Number(destinationChainIdStr)
@@ -457,6 +455,42 @@ export async function commitIntentConfig(
   }
 }
 
+export async function executeIntent(
+  trailsClient: TrailsClient,
+  intentId: string,
+  depositTransactionHash?: string,
+  depositSignature?: DepositSignature,
+) {
+  trailsClient = await getLocalClientIfEnabled(trailsClient)
+
+  logger.console.log("[trails-sdk] executeIntent inputs:", {
+    intentId,
+    depositTransactionHash,
+    hasDepositSignature: !!depositSignature,
+  })
+
+  // Validate that we have either traditional or gasless deposit params
+  if (!depositTransactionHash && !depositSignature) {
+    throw new Error(
+      "[trails-sdk] Either depositTransactionHash or depositSignature must be provided",
+    )
+  }
+
+  const request: ExecuteIntentRequest = {
+    intentId,
+    depositTransactionHash,
+    depositSignature,
+  }
+
+  logger.console.log("[trails-sdk] executeIntent request:", request)
+
+  // Call the actual API endpoint
+  const response = await trailsClient.executeIntent(request)
+  logger.console.log("[trails-sdk] executeIntent response:", response)
+
+  return response
+}
+
 export async function sendOriginTransaction(
   account: Account,
   walletClient: WalletClient,
@@ -636,7 +670,7 @@ export function hashIntentParams({
   userAddress: Address.Address
   nonce: bigint
   originTokens: OriginTokenParam[]
-  destinationCalls: Array<IntentCallsPayload>
+  destinationCalls: Array<IntentCalls>
   destinationTokens: DestinationTokenParam[]
 }): string {
   if (
@@ -748,7 +782,7 @@ export function hashIntentParams({
 
 export function calculateIntentConfigurationAddress(
   mainSigner: Address.Address,
-  calls: Array<IntentCallsPayload>,
+  calls: Array<IntentCalls>,
   context: Context.Context,
 ): Address.Address {
   const config = createIntentConfiguration(mainSigner, calls)
@@ -772,7 +806,7 @@ export function calculateIntentConfigurationAddress(
 
 function createIntentConfiguration(
   mainSigner: Address.Address,
-  calls: IntentCallsPayload[],
+  calls: IntentCalls[],
 ): Config.Config {
   const mainSignerLeaf: Config.SignerLeaf = {
     type: "signer",
@@ -881,7 +915,7 @@ function buildMerkleTreeFromMembers(
  * Build transaction parameters for same-chain same-token transactions
  * Centralizes the logic for determining transaction destination, data, and value
  */
-export function buildSameChainTransactionParams({
+export function buildSameChainSameTokenTransactionParams({
   hasCustomCalldata,
   recipient,
   effectiveOriginTokenAddress,

package/src/morpho.ts

@@ -1,5 +1,5 @@
 import { useMemo, useState, useEffect } from "react"
-import type { Address, PublicClient } from "viem"
+import type { Address, PublicClient, WalletClient } from "viem"
 import { encodeFunctionData } from "viem"
 import { logger } from "./logger.js"
 
@@ -428,16 +428,17 @@ export async function getAllVaults(
 
 /**
  * Generate Morpho vault withdraw calldata
- * @param asset - The address of the underlying asset to withdraw
- * @param amount - The amount to withdraw in wei (or max uint256 for full balance)
- * @param to - The address that will receive the underlying tokens
+ * @param amount - The amount of underlying assets to withdraw in wei
+ * @param to - The address that will receive the underlying tokens (receiver)
+ * @param owner - Optional owner address (defaults to 'to' if not provided)
  * @returns Encoded calldata for Morpho withdraw function
  */
 export function generateMorphoWithdrawCalldata(
-  asset: string,
   amount: bigint,
   to: string,
+  owner?: string,
 ): `0x${string}` {
+  const ownerAddress = owner || to
   return encodeFunctionData({
     abi: [
       {
@@ -445,16 +446,64 @@ export function generateMorphoWithdrawCalldata(
         type: "function",
         stateMutability: "nonpayable",
         inputs: [
-          { name: "asset", type: "address" },
-          { name: "amount", type: "uint256" },
-          { name: "to", type: "address" },
+          { name: "assets", type: "uint256" },
+          { name: "receiver", type: "address" },
+          { name: "owner", type: "address" },
         ],
         outputs: [{ type: "uint256" }],
       },
     ],
     functionName: "withdraw",
-    args: [asset as `0x${string}`, amount, to as `0x${string}`],
+    args: [amount, to as `0x${string}`, ownerAddress as `0x${string}`],
   })
 }
 
+// Generate deposit calldata for Morpho pool
+export const generateMorphoDepositCalldata = (
+  walletClient: WalletClient,
+  amount: string,
+) => {
+  try {
+    const userAddress = walletClient?.account?.address || walletClient?.account
+    if (!userAddress) {
+      throw new Error("User address not found")
+    }
+
+    // Validate amount
+    if (
+      !amount ||
+      amount === "" ||
+      Number.isNaN(Number(amount)) ||
+      Number(amount) <= 0
+    ) {
+      throw new Error("Invalid amount")
+    }
+
+    // Morpho Vault deposit function
+    // function deposit(uint256 amount, address receiver)
+    const calldata = encodeFunctionData({
+      abi: [
+        {
+          name: "deposit",
+          type: "function",
+          inputs: [
+            { name: "amount", type: "uint256" },
+            { name: "receiver", type: "address" },
+          ],
+          outputs: [{ name: "shares", type: "uint256" }],
+          stateMutability: "nonpayable",
+        },
+      ],
+      args: [
+        BigInt(amount), // amount to deposit
+        userAddress as `0x${string}`, // receiver (user's address)
+      ],
+    })
+    return calldata
+  } catch (error) {
+    logger.console.error("Error generating Morpho deposit calldata:", error)
+    return undefined
+  }
+}
+
 export default useMorphoVaults