0xtrails 0.2.2 → 0.2.5

package/src/metaTxnMonitor.ts

@@ -1,4 +1,11 @@
-import type { Relayer } from "@0xsequence/wallet-core"
+import type {
+  RelayerOperationConfirmedStatus,
+  RelayerOperationFailedStatus,
+  RelayerOperationPendingStatus,
+  RelayerOperationStatus,
+  RelayerOperationUnknownStatus,
+} from "./relayer.js"
+import type { Relayer } from "@0xsequence/relayer"
 import { type Query, useQueries } from "@tanstack/react-query"
 import { useMemo } from "react"
 import type { Hex } from "viem"
@@ -13,22 +20,22 @@ export type MetaTxn = {
 }
 
 export type MetaTxnStatus = {
-  [key: string]: Relayer.OperationStatus
+  [key: string]: RelayerOperationStatus
 }
 
 const POLL_INTERVAL = 3_000 // 3 seconds
 
 export const getMetaTxStatus = async (
-  relayer: Relayer.Standard.Rpc.RpcRelayer,
+  relayer: Relayer.RpcRelayer,
   metaTxId: string,
   chainId: number,
-): Promise<Relayer.OperationStatus> => {
+): Promise<RelayerOperationStatus> => {
   return relayer.status(metaTxId as `0x${string}`, chainId)
 }
 
 export const useMetaTxnsMonitor = (
   metaTxns: MetaTxn[] | undefined,
-  getRelayer: (chainId: number) => Relayer.Standard.Rpc.RpcRelayer,
+  getRelayer: (chainId: number) => Relayer.RpcRelayer,
 ) => {
   const results = useQueries({
     queries: (metaTxns || []).map((metaTxn) => {
@@ -36,21 +43,21 @@ export const useMetaTxnsMonitor = (
 
       return {
         queryKey: ["metaTxnStatus", metaTxn.chainId, metaTxn.id],
-        queryFn: async (): Promise<Relayer.OperationStatus> => {
+        queryFn: async (): Promise<RelayerOperationStatus> => {
           const relayer = getRelayer(parseInt(metaTxn.chainId, 10))
 
           if (!opHashToPoll) {
             return {
               status: "failed",
               reason: "Missing operation hash for monitoring.",
-            } as Relayer.OperationFailedStatus
+            } as RelayerOperationFailedStatus
           }
 
           if (!relayer) {
             return {
               status: "failed",
               reason: `Relayer not available for chain ${metaTxn.chainId}.`,
-            } as Relayer.OperationFailedStatus
+            } as RelayerOperationFailedStatus
           }
 
           const opStatus = await relayer.status(
@@ -58,28 +65,28 @@ export const useMetaTxnsMonitor = (
             Number(metaTxn.chainId),
           )
 
-          let newStatusEntry: Relayer.OperationStatus
+          let newStatusEntry: RelayerOperationStatus
 
           if (opStatus.status === "confirmed") {
             newStatusEntry = {
               status: "confirmed",
               transactionHash: opStatus.transactionHash,
               data: opStatus.data,
-            } as Relayer.OperationConfirmedStatus
+            } as RelayerOperationConfirmedStatus
           } else if (opStatus.status === "failed") {
             newStatusEntry = {
               status: "failed",
               reason: opStatus.reason,
               data: opStatus.data,
-            } as Relayer.OperationFailedStatus
+            } as RelayerOperationFailedStatus
           } else if (opStatus.status === "pending") {
             newStatusEntry = {
               status: "pending",
-            } as Relayer.OperationPendingStatus
+            } as RelayerOperationPendingStatus
           } else if (opStatus.status === "unknown") {
             newStatusEntry = {
               status: "unknown",
-            } as Relayer.OperationUnknownStatus
+            } as RelayerOperationUnknownStatus
           } else {
             const originalStatus = (opStatus as any).status as string
             logger.console.warn(
@@ -88,16 +95,16 @@ export const useMetaTxnsMonitor = (
             )
             newStatusEntry = {
               status: "unknown",
-            } as Relayer.OperationUnknownStatus
+            } as RelayerOperationUnknownStatus
           }
           return newStatusEntry
         },
         refetchIntervalInBackground: true,
         refetchInterval: (
           query: Query<
-            Relayer.OperationStatus,
+            RelayerOperationStatus,
             Error,
-            Relayer.OperationStatus,
+            RelayerOperationStatus,
             ReadonlyArray<unknown>
           >,
         ) => {
@@ -135,27 +142,26 @@ export const useMetaTxnsMonitor = (
         ) {
           newStatuses[operationKey] = {
             status: "pending",
-          } as Relayer.OperationPendingStatus
+          } as RelayerOperationPendingStatus
         } else if (queryResult.isError) {
           newStatuses[operationKey] = {
             status: "failed",
             reason:
               (queryResult.error as Error)?.message ||
               "An unknown error occurred",
-          } as Relayer.OperationFailedStatus
+          } as RelayerOperationFailedStatus
         } else if (queryResult.data) {
-          newStatuses[operationKey] =
-            queryResult.data as Relayer.OperationStatus
+          newStatuses[operationKey] = queryResult.data as RelayerOperationStatus
         } else {
           newStatuses[operationKey] = {
             status: "unknown",
-          } as Relayer.OperationUnknownStatus
+          } as RelayerOperationUnknownStatus
         }
       } else {
         newStatuses[operationKey] = {
           status: "failed",
           reason: "Query result unexpectedly missing",
-        } as Relayer.OperationFailedStatus
+        } as RelayerOperationFailedStatus
       }
     })
     return newStatuses

package/src/metaTxns.ts

@@ -1,11 +1,11 @@
+import type { Relayer } from "@0xsequence/relayer"
 import type { IntentPrecondition } from "@0xsequence/trails-api"
-import type { Relayer } from "@0xsequence/wallet-core"
 import type { Hex } from "viem"
 import type { MetaTxn } from "./metaTxnMonitor.js"
 import { logger } from "./logger.js"
 
 export async function relayerSendMetaTx(
-  relayer: Relayer.Standard.Rpc.RpcRelayer,
+  relayer: Relayer.RpcRelayer,
   metaTx: MetaTxn,
   preconditions: IntentPrecondition[],
   feeQuote?: Relayer.FeeQuote,
@@ -23,7 +23,7 @@ export async function relayerSendMetaTx(
 }
 
 export async function getMetaTxnReceipt(
-  relayer: Relayer.Standard.Rpc.RpcRelayer,
+  relayer: Relayer.RpcRelayer,
   metaTxId: string,
   chainId: number,
 ): Promise<{ receipt: { status: "confirmed" | "failed" | "pending" } }> {

package/src/morpho.ts

@@ -1,5 +1,6 @@
 import { useMemo, useState, useEffect } from "react"
 import type { Address, PublicClient } from "viem"
+import { encodeFunctionData } from "viem"
 import { logger } from "./logger.js"
 
 type AccrualPosition = any
@@ -425,4 +426,35 @@ export async function getAllVaults(
   return transformedVaults
 }
 
+/**
+ * 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
+ * @returns Encoded calldata for Morpho withdraw function
+ */
+export function generateMorphoWithdrawCalldata(
+  asset: string,
+  amount: bigint,
+  to: string,
+): `0x${string}` {
+  return encodeFunctionData({
+    abi: [
+      {
+        name: "withdraw",
+        type: "function",
+        stateMutability: "nonpayable",
+        inputs: [
+          { name: "asset", type: "address" },
+          { name: "amount", type: "uint256" },
+          { name: "to", type: "address" },
+        ],
+        outputs: [{ type: "uint256" }],
+      },
+    ],
+    functionName: "withdraw",
+    args: [asset as `0x${string}`, amount, to as `0x${string}`],
+  })
+}
+
 export default useMorphoVaults