0xtrails 0.0.1 → 0.0.2

package/dist/trails.js

@@ -0,0 +1,1031 @@
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { Address } from "ox";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createPublicClient, createWalletClient, custom, http, isAddress, isAddressEqual, zeroAddress, } from "viem";
+import { useEstimateGas, useSendTransaction, useSwitchChain, useWaitForTransactionReceipt, } from "wagmi";
+import { useAPIClient } from "./apiClient.js";
+import { attemptSwitchChain } from "./chainSwitch.js";
+import { getChainInfo } from "./chains.js";
+import { TRAILS_CCTP_SAPIENT_SIGNER_ADDRESS, TRAILS_LIFI_SAPIENT_SIGNER_ADDRESS, TRAILS_RELAY_SAPIENT_SIGNER_ADDRESS, DEFAULT_USE_V3_RELAYERS, } from "./constants.js";
+import { getERC20TransferData } from "./encoders.js";
+import { calculateIntentAddress, calculateOriginAndDestinationIntentAddresses, getIntentCallsPayloads as getIntentCallsPayloadsFromIntents, } from "./intents.js";
+import { useMetaTxnsMonitor } from "./metaTxnMonitor.js";
+import { findPreconditionAddresses } from "./preconditions.js";
+import { getBackupRelayer, useRelayers } from "./relayer.js";
+const RETRY_WINDOW_MS = 10_000;
+export function useTrails(config) {
+    const { account, disableAutoExecute = false, env, useV3Relayers = DEFAULT_USE_V3_RELAYERS, sequenceProjectAccessKey, } = config;
+    const apiClient = useAPIClient({ projectAccessKey: sequenceProjectAccessKey });
+    const [isAutoExecute, setIsAutoExecute] = useState(!disableAutoExecute);
+    const [hasAutoExecuted, setHasAutoExecuted] = useState(false);
+    // Track timestamps of when each meta-transaction was last sent
+    const [sentMetaTxns, setSentMetaTxns] = useState({});
+    // State declarations
+    const [metaTxns, setMetaTxns] = useState(null);
+    const [intentCallsPayloads, setIntentCallsPayloads] = useState(null);
+    const [intentPreconditions, setIntentPreconditions] = useState(null);
+    const [trailsFee, setTrailsFee] = useState(null);
+    const [txnHash, setTxnHash] = useState();
+    const [committedOriginIntentAddress, setCommittedOriginIntentAddress] = useState(null);
+    const [committedDestinationIntentAddress, setCommittedDestinationIntentAddress,] = useState(null);
+    const [originIntentAddress, setOriginIntentAddress] = useState(null);
+    const [destinationIntentAddress, setDestinationIntentAddress] = useState(null);
+    // const [preconditionStatuses, setPreconditionStatuses] = useState<boolean[]>([])
+    const [originCallParams, setOriginCallParams] = useState(null);
+    const [operationHashes, setOperationHashes] = useState({});
+    const [isTransactionInProgress, setIsTransactionInProgress] = useState(false);
+    const [isChainSwitchRequired, setIsChainSwitchRequired] = useState(false);
+    const { switchChain, isPending: isSwitchingChain, error: switchChainError, } = useSwitchChain();
+    const sendOriginTxn = useSendTransaction();
+    const [isEstimatingGas, setIsEstimatingGas] = useState(false);
+    const [originCallStatus, setOriginCallStatus] = useState(null);
+    const [originBlockTimestamp, setOriginBlockTimestamp] = useState(null);
+    const [metaTxnBlockTimestamps, setMetaTxnBlockTimestamps] = useState({});
+    const [verificationStatus, setVerificationStatus] = useState(null);
+    const { getRelayer } = useRelayers({
+        env,
+        useV3Relayers,
+    });
+    // Add gas estimation hook with proper types
+    const { data: estimatedGas, isError: isEstimateError, error: estimateError, } = useEstimateGas(originCallParams?.to && originCallParams?.chainId && !originCallParams.error
+        ? {
+            to: originCallParams.to || undefined,
+            data: originCallParams.data || undefined,
+            value: originCallParams.value || undefined,
+            chainId: originCallParams.chainId || undefined,
+        }
+        : undefined);
+    const commitIntentConfigMutation = useMutation({
+        mutationFn: async (args) => {
+            console.log("[useTrails] commitIntentConfigMutation started with args:", args);
+            if (!apiClient) {
+                console.error("[useTrails] API client not available");
+                throw new Error("API client not available");
+            }
+            if (!args.quoteProvider) {
+                console.error("[useTrails] quoteProvider is required");
+                throw new Error("quoteProvider is required");
+            }
+            try {
+                console.log("[useTrails] Calculating intent address...");
+                console.log("[useTrails] Main signer:", args.mainSignerAddress);
+                console.log("[useTrails] Calls:", args.calls);
+                const originChainId = createIntentMutation.variables?.originChainId;
+                const destinationChainId = createIntentMutation.variables?.destinationChainId;
+                if (!originChainId || !destinationChainId) {
+                    console.error("[useTrails] Could not determine origin/destination chain IDs for verification.");
+                    throw new Error("Could not determine origin/destination chain IDs for verification.");
+                }
+                const { originIntentAddress, destinationIntentAddress } = calculateOriginAndDestinationIntentAddresses(args.mainSignerAddress, args.calls);
+                const { originAddress: originPreconditionAddress, destinationAddress: destinationPreconditionAddress, } = findPreconditionAddresses(args.preconditions, originChainId, destinationChainId);
+                console.log("[useTrails] Verification addresses:", {
+                    calculatedOrigin: originIntentAddress.toString(),
+                    calculatedDestination: destinationIntentAddress.toString(),
+                    preconditionOrigin: originPreconditionAddress,
+                    preconditionDestination: destinationPreconditionAddress,
+                });
+                const isOriginVerified = !!originPreconditionAddress &&
+                    isAddressEqual(Address.from(originPreconditionAddress), originIntentAddress);
+                // For single chain, destination address may not be in preconditions,
+                // but the destination intent address should be the zero address.
+                const isDestinationVerified = (destinationPreconditionAddress &&
+                    isAddressEqual(Address.from(destinationPreconditionAddress), destinationIntentAddress)) ||
+                    (!destinationPreconditionAddress &&
+                        originChainId === destinationChainId &&
+                        isAddressEqual(destinationIntentAddress, zeroAddress));
+                const isVerified = isOriginVerified && isDestinationVerified;
+                setVerificationStatus({
+                    success: isVerified,
+                    receivedOriginAddress: originPreconditionAddress,
+                    receivedDestinationAddress: destinationPreconditionAddress,
+                    calculatedOriginAddress: originIntentAddress.toString(),
+                    calculatedDestinationAddress: destinationIntentAddress.toString(),
+                });
+                if (!isVerified) {
+                    console.error("[useTrails] Address verification failed.", {
+                        isOriginVerified,
+                        isDestinationVerified,
+                    });
+                    throw new Error(`Address verification failed. Origin verified: ${isOriginVerified}, Destination verified: ${isDestinationVerified}`);
+                }
+                // Commit the intent config
+                console.log("[useTrails] Committing intent config to API...");
+                const response = await apiClient.commitIntentConfig({
+                    originIntentAddress: originIntentAddress.toString(),
+                    destinationIntentAddress: destinationIntentAddress.toString(),
+                    mainSigner: args.mainSignerAddress,
+                    calls: args.calls,
+                    preconditions: args.preconditions,
+                    addressOverrides: {
+                        trailsLiFiSapientSignerAddress: TRAILS_LIFI_SAPIENT_SIGNER_ADDRESS,
+                        trailsRelaySapientSignerAddress: TRAILS_RELAY_SAPIENT_SIGNER_ADDRESS,
+                        trailsCCTPV2SapientSignerAddress: TRAILS_CCTP_SAPIENT_SIGNER_ADDRESS,
+                        ...args.addressOverrides,
+                    },
+                });
+                console.log("[useTrails] API Commit Response:", response);
+                return {
+                    originIntentAddress: originIntentAddress.toString(),
+                    destinationIntentAddress: destinationIntentAddress.toString(),
+                    response,
+                };
+            }
+            catch (error) {
+                console.error("[useTrails] Error during commit intent mutation:", error);
+                throw error;
+            }
+        },
+        onSuccess: (data) => {
+            console.log("[useTrails] Intent config committed successfully. Data:", data);
+            console.log("[useTrails] Setting committedOriginIntentAddress:", data.originIntentAddress);
+            setCommittedOriginIntentAddress(data.originIntentAddress);
+            setCommittedDestinationIntentAddress(data.destinationIntentAddress);
+        },
+        onError: (error) => {
+            console.error("[useTrails] Failed to commit intent config:", error);
+            setCommittedOriginIntentAddress(null);
+            setCommittedDestinationIntentAddress(null);
+        },
+    });
+    // New Query to fetch committed intent config
+    const { data: committedIntentConfig, isLoading: isLoadingCommittedConfig, error: committedConfigError, } = useQuery({
+        queryKey: ["getIntentConfig", committedOriginIntentAddress],
+        queryFn: async () => {
+            if (!apiClient || !committedOriginIntentAddress) {
+                throw new Error("API client or committed intent address not available");
+            }
+            console.log("Fetching intent config for address:", committedOriginIntentAddress);
+            return await apiClient.getIntentConfig({
+                intentAddress: committedOriginIntentAddress,
+            });
+        },
+        enabled: !!committedOriginIntentAddress &&
+            !!apiClient &&
+            commitIntentConfigMutation.isSuccess,
+        staleTime: 1000 * 60 * 5, // 5 minutes
+        retry: 1,
+    });
+    async function getIntentCallsPayloads(args) {
+        return getIntentCallsPayloadsFromIntents(apiClient, {
+            ...args,
+            addressOverrides: {
+                trailsLiFiSapientSignerAddress: TRAILS_LIFI_SAPIENT_SIGNER_ADDRESS,
+                trailsRelaySapientSignerAddress: TRAILS_RELAY_SAPIENT_SIGNER_ADDRESS,
+                trailsCCTPV2SapientSignerAddress: TRAILS_CCTP_SAPIENT_SIGNER_ADDRESS,
+                ...args.addressOverrides,
+            },
+        });
+    }
+    // TODO: Add type for args
+    const createIntentMutation = useMutation({
+        mutationFn: async (args) => {
+            if (args.originChainId === args.destinationChainId &&
+                isAddressEqual(Address.from(args.originTokenAddress), Address.from(args.destinationTokenAddress))) {
+                throw new Error("The same token cannot be used as both the source and destination token.");
+            }
+            if (!account.address) {
+                throw new Error("Missing selected token or account address");
+            }
+            // Reset commit state when generating a new intent
+            setCommittedOriginIntentAddress(null);
+            setCommittedDestinationIntentAddress(null);
+            setVerificationStatus(null);
+            setTrailsFee(null);
+            setMetaTxns(null);
+            setIntentCallsPayloads(null);
+            setIntentPreconditions(null);
+            setOriginIntentAddress(null);
+            setDestinationIntentAddress(null);
+            const data = await getIntentCallsPayloads(args);
+            setMetaTxns(data.metaTxns);
+            setIntentCallsPayloads(data.calls);
+            setIntentPreconditions(data.preconditions);
+            setTrailsFee(data.trailsFee);
+            setOriginIntentAddress(data.originIntentAddress);
+            setDestinationIntentAddress(data.destinationIntentAddress);
+            setCommittedOriginIntentAddress(null);
+            setCommittedDestinationIntentAddress(null);
+            setVerificationStatus(null);
+            return data;
+        },
+        onSuccess: (data) => {
+            console.log("Intent Config Success:", data);
+            setTrailsFee(data.trailsFee || null);
+            setOriginIntentAddress(data.originIntentAddress);
+            setDestinationIntentAddress(data.destinationIntentAddress);
+            if (data?.calls &&
+                data.calls.length > 0 &&
+                data.preconditions &&
+                data.preconditions.length > 0 &&
+                data.metaTxns &&
+                data.metaTxns.length > 0) {
+                setIntentCallsPayloads(data.calls);
+                setIntentPreconditions(data.preconditions);
+                setMetaTxns(data.metaTxns);
+            }
+            else {
+                console.warn("API returned success but no operations found.");
+                setIntentCallsPayloads(null);
+                setIntentPreconditions(null);
+                setMetaTxns(null);
+            }
+        },
+        onError: (error) => {
+            console.error("Intent Config Error:", error);
+            setIntentCallsPayloads(null);
+            setIntentPreconditions(null);
+            setMetaTxns(null);
+            setTrailsFee(null);
+            setOriginIntentAddress(null);
+            setDestinationIntentAddress(null);
+        },
+    });
+    function callIntentCallsPayload(args) {
+        createIntentMutation.mutate(args);
+    }
+    const clearIntent = useCallback(() => {
+        console.log("[Trails] Clearing intent state");
+        setIntentCallsPayloads(null);
+        setIntentPreconditions(null);
+        setMetaTxns(null);
+        setTrailsFee(null);
+        setCommittedOriginIntentAddress(null);
+        setCommittedDestinationIntentAddress(null);
+        setVerificationStatus(null);
+        setOriginIntentAddress(null);
+        setDestinationIntentAddress(null);
+        setOperationHashes({});
+        setHasAutoExecuted(false);
+        setMetaTxnBlockTimestamps({});
+    }, []); // Empty deps array since these setters are stable
+    const updateOriginCallStatus = useCallback((hash, status, gasUsed, effectiveGasPrice, revertReason) => {
+        setOriginCallStatus({
+            txnHash: hash,
+            status: status === "success"
+                ? "Success"
+                : status === "reverted"
+                    ? "Failed"
+                    : status === "sending"
+                        ? "Sending..."
+                        : "Pending",
+            revertReason: status === "reverted"
+                ? revertReason || "Transaction reverted"
+                : undefined,
+            gasUsed: gasUsed ? Number(gasUsed) : undefined,
+            effectiveGasPrice: effectiveGasPrice?.toString(),
+        });
+    }, []);
+    const sendOriginTransaction = async () => {
+        console.log("Sending origin transaction...");
+        console.log(isTransactionInProgress, originCallParams, originCallParams?.error, originCallParams?.to, originCallParams?.data, originCallParams?.value, originCallParams?.chainId);
+        if (isTransactionInProgress || // Prevent duplicate transactions
+            !originCallParams ||
+            originCallParams.error ||
+            !originCallParams.to ||
+            originCallParams.data === null ||
+            originCallParams.value === null ||
+            originCallParams.chainId === null) {
+            console.error("Origin call parameters not available or invalid:", originCallParams);
+            updateOriginCallStatus(undefined, "reverted", undefined, undefined, "Origin call parameters not ready");
+            return;
+        }
+        // Check if we need to switch chains
+        if (account.chainId !== originCallParams.chainId) {
+            setIsChainSwitchRequired(true);
+            updateOriginCallStatus(undefined, "pending", undefined, undefined, `Switching to chain ${originCallParams.chainId}...`);
+            const walletClient = createWalletClient({
+                chain: getChainInfo(originCallParams.chainId),
+                transport: custom((await account.connector.getProvider())), // TODO: Add proper type
+            });
+            try {
+                await attemptSwitchChain({
+                    walletClient,
+                    desiredChainId: originCallParams.chainId,
+                });
+                setIsChainSwitchRequired(false);
+            }
+            catch (error) {
+                console.error("Chain switch failed:", error);
+                if (error instanceof Error && error.message.includes("User rejected")) {
+                    setIsAutoExecute(false);
+                }
+                updateOriginCallStatus(undefined, "reverted", undefined, undefined, error instanceof Error
+                    ? error.message
+                    : "Unknown error switching chain");
+                setIsChainSwitchRequired(false);
+                return; // Stop execution on switch failure
+            }
+        }
+        // Ensure only one transaction is sent at a time
+        if (!isTransactionInProgress) {
+            setIsTransactionInProgress(true); // Mark transaction as in progress
+            setTxnHash(undefined);
+            updateOriginCallStatus(undefined, "sending");
+            if (!estimatedGas && !isEstimateError) {
+                setIsEstimatingGas(true);
+                return; // Wait for gas estimation
+            }
+            if (isEstimateError) {
+                console.error("Gas estimation failed:", estimateError);
+                updateOriginCallStatus(undefined, "reverted", undefined, undefined, `Gas estimation failed: ${estimateError?.message}`);
+                setIsTransactionInProgress(false);
+                return;
+            }
+            // Add 20% buffer to estimated gas
+            const gasLimit = estimatedGas
+                ? BigInt(Math.floor(Number(estimatedGas) * 1.2))
+                : undefined;
+            sendOriginTxn.sendTransaction({
+                to: originCallParams.to,
+                data: originCallParams.data,
+                value: originCallParams.value,
+                chainId: originCallParams.chainId,
+                gas: gasLimit,
+            }, {
+                onSuccess: (hash) => {
+                    console.log("Transaction sent, hash:", hash);
+                    setTxnHash(hash);
+                    setIsTransactionInProgress(false); // Reset transaction state
+                },
+                onError: (error) => {
+                    console.error("Transaction failed:", error);
+                    if (error instanceof Error &&
+                        (error.message.includes("User rejected") ||
+                            error.message.includes("user rejected"))) {
+                        setIsAutoExecute(false);
+                    }
+                    updateOriginCallStatus(undefined, "reverted", undefined, undefined, error instanceof Error ? error.message : "Unknown error");
+                    setIsTransactionInProgress(false);
+                },
+            });
+        }
+        else {
+            console.warn("Transaction already in progress. Skipping duplicate request.");
+        }
+    };
+    // Remove the chain change effect that might be resetting state
+    useEffect(() => {
+        if (switchChainError) {
+            console.error("Chain switch error:", switchChainError);
+            updateOriginCallStatus(undefined, "reverted", undefined, undefined, `Chain switch failed: ${switchChainError.message || "Unknown error"}`);
+            setIsChainSwitchRequired(false);
+        }
+    }, [switchChainError, updateOriginCallStatus]);
+    // Reset gas estimation state when parameters change
+    useEffect(() => {
+        setIsEstimatingGas(false);
+    }, []);
+    // Only update chain switch required state when needed
+    useEffect(() => {
+        if (originCallParams?.chainId &&
+            account.chainId === originCallParams.chainId) {
+            console.log("No chain switch required");
+            setIsChainSwitchRequired(false);
+        }
+    }, [account.chainId, originCallParams?.chainId]);
+    // Effect to handle chain switching
+    useEffect(() => {
+        if (originCallParams?.chainId &&
+            account.chainId !== originCallParams.chainId) {
+            async function check() {
+                try {
+                    const chainId = originCallParams.chainId;
+                    const walletClient = createWalletClient({
+                        chain: getChainInfo(chainId),
+                        transport: custom((await account.connector.getProvider())), // TODO: Add proper type
+                    });
+                    await attemptSwitchChain({
+                        walletClient,
+                        desiredChainId: chainId,
+                    });
+                }
+                catch (error) {
+                    console.error("Chain switch failed:", error);
+                }
+            }
+            check().catch(console.error);
+        }
+    }, [account, originCallParams]);
+    // Hook to wait for transaction receipt
+    const { data: receipt, isLoading: isWaitingForReceipt, isSuccess: receiptIsSuccess, isError: receiptIsError, error: receiptError, } = useWaitForTransactionReceipt({
+        hash: txnHash,
+        confirmations: 1,
+        query: {
+            enabled: !!txnHash,
+        },
+    });
+    // Modify the effect that watches for transaction status
+    // biome-ignore lint/correctness/useExhaustiveDependencies: False positive
+    useEffect(() => {
+        if (!txnHash) {
+            // Only reset these when txnHash is cleared
+            if (originCallStatus?.txnHash) {
+                setOriginCallStatus(null);
+            }
+            setOriginBlockTimestamp(null);
+            if (Object.keys(sentMetaTxns).length > 0) {
+                setSentMetaTxns({});
+            }
+            return;
+        }
+        if (originCallStatus?.txnHash === txnHash &&
+            (originCallStatus?.status === "Success" ||
+                originCallStatus?.status === "Failed") &&
+            !isWaitingForReceipt) {
+            return;
+        }
+        if (isWaitingForReceipt) {
+            setOriginCallStatus((prevStatus) => ({
+                ...(prevStatus?.txnHash === txnHash
+                    ? prevStatus
+                    : {
+                        gasUsed: undefined,
+                        effectiveGasPrice: undefined,
+                        revertReason: undefined,
+                    }),
+                txnHash,
+                status: "Pending",
+            }));
+            return;
+        }
+        if (receiptIsSuccess && receipt) {
+            const newStatus = receipt.status === "success" ? "Success" : "Failed";
+            setOriginCallStatus({
+                txnHash: receipt.transactionHash,
+                status: newStatus,
+                gasUsed: receipt.gasUsed ? Number(receipt.gasUsed) : undefined,
+                effectiveGasPrice: receipt.effectiveGasPrice?.toString(),
+                revertReason: receipt.status === "reverted"
+                    ? receiptError?.message ||
+                        "Transaction reverted by receipt"
+                    : undefined,
+            });
+            if (newStatus === "Success" && receipt.blockNumber) {
+                const fetchTimestamp = async () => {
+                    try {
+                        if (!originCallParams?.chainId) {
+                            console.error("[Trails] Origin chainId not available for fetching origin block timestamp.");
+                            setOriginBlockTimestamp(null);
+                            return;
+                        }
+                        const chainConfig = getChainInfo(originCallParams.chainId);
+                        const client = createPublicClient({
+                            chain: chainConfig,
+                            transport: http(),
+                        });
+                        const block = await client.getBlock({
+                            blockNumber: BigInt(receipt.blockNumber),
+                        });
+                        setOriginBlockTimestamp(Number(block.timestamp));
+                    }
+                    catch (error) {
+                        console.error("[Trails] Error fetching origin block timestamp:", error);
+                        setOriginBlockTimestamp(null);
+                    }
+                };
+                fetchTimestamp();
+            }
+            else if (newStatus !== "Success") {
+                setOriginBlockTimestamp(null);
+            }
+            if (newStatus === "Success" &&
+                metaTxns &&
+                metaTxns.length > 0 &&
+                isAutoExecute &&
+                !metaTxns.some((tx) => sentMetaTxns[`${tx.chainId}-${tx.id}`])) {
+                console.log("Origin transaction successful, auto-sending all meta transactions...");
+                sendMetaTxnMutation.mutate({ selectedId: null });
+            }
+        }
+        else if (receiptIsError) {
+            setOriginCallStatus({
+                txnHash,
+                status: "Failed",
+                revertReason: receiptError?.message ||
+                    "Failed to get receipt",
+                gasUsed: undefined,
+                effectiveGasPrice: undefined,
+            });
+            setOriginBlockTimestamp(null);
+        }
+    }, [
+        txnHash,
+        isWaitingForReceipt,
+        receiptIsSuccess,
+        receiptIsError,
+        receipt,
+        receiptError,
+        metaTxns,
+        sentMetaTxns,
+        isAutoExecute,
+        originCallParams?.chainId,
+        originCallStatus?.status,
+        originCallStatus?.txnHash,
+    ]);
+    // Modify the auto-execute effect
+    useEffect(() => {
+        const shouldAutoSend = isAutoExecute &&
+            commitIntentConfigMutation.isSuccess &&
+            originCallParams?.chainId &&
+            account.chainId === originCallParams.chainId &&
+            !originCallParams.error &&
+            originCallParams.to &&
+            originCallParams.data !== null &&
+            originCallParams.value !== null &&
+            !sendOriginTxn.isPending &&
+            !isWaitingForReceipt &&
+            !txnHash &&
+            !isChainSwitchRequired &&
+            !originCallStatus &&
+            !hasAutoExecuted;
+        if (shouldAutoSend) {
+            console.log("Auto-executing transaction: All conditions met.");
+            setHasAutoExecuted(true);
+            // Set initial status
+            setOriginCallStatus({
+                status: "Sending...",
+            });
+            sendOriginTxn.sendTransaction({
+                to: originCallParams.to,
+                data: originCallParams.data,
+                value: originCallParams.value,
+                chainId: originCallParams.chainId,
+            }, {
+                onSuccess: (hash) => {
+                    console.log("Auto-executed transaction sent, hash:", hash);
+                    setTxnHash(hash);
+                },
+                onError: (error) => {
+                    console.error("Auto-executed transaction failed:", error);
+                    if (error instanceof Error &&
+                        (error.message.includes("User rejected") ||
+                            error.message.includes("user rejected"))) {
+                        setIsAutoExecute(false);
+                    }
+                    setOriginCallStatus({
+                        status: "Failed",
+                        revertReason: error instanceof Error ? error.message : "Unknown error",
+                    });
+                    setHasAutoExecuted(false);
+                },
+            });
+        }
+    }, [
+        isAutoExecute,
+        commitIntentConfigMutation.isSuccess,
+        originCallParams,
+        account.chainId,
+        sendOriginTxn.isPending,
+        isWaitingForReceipt,
+        txnHash,
+        isChainSwitchRequired,
+        originCallStatus,
+        hasAutoExecuted,
+        sendOriginTxn,
+    ]);
+    // Effect to auto-commit when intent calls payloads are ready
+    useEffect(() => {
+        if (isAutoExecute &&
+            intentCallsPayloads &&
+            intentPreconditions &&
+            trailsFee &&
+            account.address &&
+            originIntentAddress &&
+            !commitIntentConfigMutation.isPending &&
+            !commitIntentConfigMutation.isSuccess) {
+            console.log("Auto-committing intent configuration...");
+            commitIntentConfigMutation.mutate({
+                mainSignerAddress: account.address,
+                calls: intentCallsPayloads,
+                preconditions: intentPreconditions,
+                quoteProvider: trailsFee.quoteProvider,
+                addressOverrides: createIntentMutation.variables?.addressOverrides,
+            });
+        }
+    }, [
+        isAutoExecute,
+        intentCallsPayloads,
+        intentPreconditions,
+        trailsFee,
+        account.address,
+        originIntentAddress,
+        commitIntentConfigMutation,
+        createIntentMutation.variables,
+    ]);
+    // Update the sendMetaTxn mutation
+    const sendMetaTxnMutation = useMutation({
+        mutationFn: async ({ selectedId }) => {
+            if (!intentCallsPayloads ||
+                !intentPreconditions ||
+                !metaTxns ||
+                !account.address) {
+                throw new Error("Missing required data for meta-transaction");
+            }
+            if (!trailsFee?.quoteProvider) {
+                throw new Error("quoteProvider is required");
+            }
+            const intentAddress = calculateIntentAddress(account.address, intentCallsPayloads);
+            // If no specific ID is selected, send all meta transactions
+            const txnsToSend = selectedId
+                ? [metaTxns.find((tx) => tx.id === selectedId)]
+                : metaTxns;
+            if (!txnsToSend || (selectedId && !txnsToSend[0])) {
+                throw new Error("Meta transaction not found");
+            }
+            const results = [];
+            for (const metaTxn of txnsToSend) {
+                if (!metaTxn)
+                    continue;
+                const operationKey = `${metaTxn.chainId}-${metaTxn.id}`;
+                const lastSentTime = sentMetaTxns[operationKey];
+                const now = Date.now();
+                if (lastSentTime && now - lastSentTime < RETRY_WINDOW_MS) {
+                    const timeLeft = Math.ceil((RETRY_WINDOW_MS - (now - lastSentTime)) / 1000);
+                    console.log(`Meta transaction for ${operationKey} was sent recently. Wait ${timeLeft}s before retry`);
+                    continue;
+                }
+                try {
+                    const chainId = parseInt(metaTxn.chainId);
+                    if (Number.isNaN(chainId) || chainId <= 0) {
+                        throw new Error(`Invalid chainId for meta transaction: ${chainId}`);
+                    }
+                    const chainRelayer = getRelayer(chainId);
+                    if (!chainRelayer) {
+                        throw new Error(`No relayer found for chainId: ${chainId}`);
+                    }
+                    const relevantPreconditions = intentPreconditions.filter((p) => p.chainId && parseInt(p.chainId) === chainId);
+                    console.log(`Relaying meta transaction ${operationKey} to intent ${intentAddress} via relayer:`, chainRelayer);
+                    const { opHash } = await chainRelayer.sendMetaTxn(metaTxn.walletAddress, metaTxn.contract, metaTxn.input, BigInt(metaTxn.chainId), undefined, relevantPreconditions);
+                    const useBackupRelayer = false; // Disable backup relayer for now
+                    if (useBackupRelayer) {
+                        try {
+                            // Fire and forget send tx to backup relayer
+                            const backupRelayer = getBackupRelayer(chainId);
+                            backupRelayer
+                                ?.sendMetaTxn(metaTxn.walletAddress, metaTxn.contract, metaTxn.input, BigInt(metaTxn.chainId), undefined, relevantPreconditions)
+                                .then(() => { })
+                                .catch(() => { });
+                        }
+                        catch { }
+                    }
+                    results.push({
+                        operationKey,
+                        opHash,
+                        success: true,
+                    });
+                }
+                catch (error) {
+                    results.push({
+                        operationKey,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        success: false,
+                    });
+                }
+            }
+            return results;
+        },
+        onSuccess: (results) => {
+            // Update states based on results
+            results.forEach(({ operationKey, opHash, success }) => {
+                if (success && opHash) {
+                    setSentMetaTxns((prev) => ({
+                        ...prev,
+                        [operationKey]: Date.now(),
+                    }));
+                    setOperationHashes((prev) => ({
+                        ...prev,
+                        [operationKey]: opHash,
+                    }));
+                }
+            });
+        },
+        onError: (error) => {
+            console.error("Error in meta-transaction process:", error);
+        },
+        retry: 5, // Allow up to 2 retries
+        retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000), // Exponential backoff
+    });
+    const [tokenAddress, setTokenAddress] = useState(null);
+    const [originChainId, setOriginChainId] = useState(null);
+    useEffect(() => {
+        if (!originIntentAddress ||
+            !intentCallsPayloads?.[0]?.chainId ||
+            !tokenAddress ||
+            !originChainId ||
+            !intentPreconditions ||
+            !account.address) {
+            setOriginCallParams(null);
+            return;
+        }
+        try {
+            const intentAddressString = originIntentAddress;
+            if (!intentAddressString || !isAddress(intentAddressString)) {
+                setOriginCallParams(null);
+                return;
+            }
+            let calcTo;
+            let calcData = "0x";
+            let calcValue = 0n;
+            const recipientAddress = intentAddressString;
+            const isNative = tokenAddress === zeroAddress;
+            if (isNative) {
+                const nativePrecondition = intentPreconditions.find((p) => (p.type === "transfer-native" || p.type === "native-balance") &&
+                    p.chainId === originChainId.toString());
+                const nativeMinAmount = nativePrecondition?.data?.minAmount?.toString() ??
+                    nativePrecondition?.data?.min?.toString();
+                if (nativeMinAmount === undefined) {
+                    throw new Error("Could not find native precondition (transfer-native or native-balance) or min amount");
+                }
+                calcValue = BigInt(nativeMinAmount);
+                calcTo = recipientAddress;
+            }
+            else {
+                const erc20Precondition = intentPreconditions.find((p) => p.type === "erc20-balance" &&
+                    p.chainId === originChainId.toString() &&
+                    p.data?.token &&
+                    isAddressEqual(Address.from(p.data.token), Address.from(tokenAddress)));
+                const erc20MinAmount = erc20Precondition?.data?.min?.toString();
+                if (erc20MinAmount === undefined) {
+                    throw new Error("Could not find ERC20 balance precondition or min amount");
+                }
+                calcData = getERC20TransferData({
+                    recipient: recipientAddress,
+                    amount: BigInt(erc20MinAmount),
+                });
+                calcTo = tokenAddress;
+            }
+            setOriginCallParams({
+                to: calcTo,
+                data: calcData,
+                value: calcValue,
+                chainId: originChainId,
+                error: undefined,
+            });
+        }
+        catch (error) {
+            console.error("[trails-sdk] Failed to calculate origin call params for UI:", error);
+            setOriginCallParams({
+                to: null,
+                data: null,
+                value: null,
+                chainId: null,
+                error: error instanceof Error ? error.message : "Unknown error",
+            });
+        }
+    }, [
+        intentCallsPayloads,
+        tokenAddress,
+        originChainId,
+        intentPreconditions,
+        account.address,
+        originIntentAddress,
+    ]);
+    // const checkPreconditionStatuses = useCallback(async () => {
+    //   if (!intentPreconditions) return
+    //   const statuses = await Promise.all(
+    //     intentPreconditions.map(async (precondition) => {
+    //       try {
+    //         const chainIdString = precondition.chainId
+    //         if (!chainIdString) {
+    //           console.warn('[trails-sdk] Precondition missing chainId:', precondition)
+    //           return false
+    //         }
+    //         const chainId = parseInt(chainIdString)
+    //         if (isNaN(chainId) || chainId <= 0) {
+    //           console.warn('[trails-sdk] Precondition has invalid chainId:', chainIdString, precondition)
+    //           return false
+    //         }
+    //         const chainRelayer = getRelayer(chainId)
+    //         if (!chainRelayer) {
+    //           console.error(`[trails-sdk] No relayer found for chainId: ${chainId}`)
+    //           return false
+    //         }
+    //         return await chainRelayer.checkPrecondition(precondition)
+    //       } catch (error) {
+    //         console.error('[trails-sdk] Error checking precondition:', error, 'Precondition:', precondition)
+    //         return false
+    //       }
+    //     }),
+    //   )
+    //   setPreconditionStatuses(statuses)
+    // }, [intentPreconditions, getRelayer])
+    // useEffect(() => {
+    //   // TODO: Remove this once we have a way to check precondition statuses
+    //   if (false) {
+    //     checkPreconditionStatuses()
+    //   }
+    // }, [intentPreconditions, checkPreconditionStatuses])
+    // Add monitoring for each meta transaction
+    const metaTxnMonitorStatuses = useMetaTxnsMonitor(metaTxns, getRelayer);
+    // Create a stable dependency for the meta timestamp effect
+    const _stableMetaTxnStatusesKey = useMemo(() => {
+        if (!metaTxns || Object.keys(metaTxnMonitorStatuses).length === 0) {
+            return "no_statuses";
+        }
+        // Sort by a stable key (e.g., id) to ensure consistent order if metaTxns array order changes
+        // but content is the same, though metaTxns itself is a dependency, so this might be redundant if metaTxns order is stable.
+        const sortedTxnIds = metaTxns
+            .map((tx) => `${tx.chainId}-${tx.id}`)
+            .sort();
+        return sortedTxnIds
+            .map((key) => {
+            const statusObj = metaTxnMonitorStatuses[key];
+            return `${key}:${statusObj ? statusObj.status : "loading"}`;
+        })
+            .join(",");
+    }, [metaTxns, metaTxnMonitorStatuses]);
+    const processedTxns = useRef(new Set());
+    // Effect to fetch meta-transaction block timestamps
+    useEffect(() => {
+        console.log("[trails-sdk] Running meta-transaction block timestamp effect:", {
+            metaTxnsLength: metaTxns?.length,
+            monitorStatusesLength: Object.keys(metaTxnMonitorStatuses).length,
+        });
+        if (!metaTxns || metaTxns.length === 0) {
+            console.log("[trails-sdk] No meta transactions, clearing timestamps");
+            processedTxns.current.clear();
+            if (Object.keys(metaTxnBlockTimestamps).length > 0) {
+                setMetaTxnBlockTimestamps({});
+            }
+            return;
+        }
+        if (!Object.keys(metaTxnMonitorStatuses).length) {
+            console.log("[trails-sdk] No monitor statuses yet, waiting...");
+            return;
+        }
+        metaTxns.forEach(async (metaTxn) => {
+            const operationKey = `${metaTxn.chainId}-${metaTxn.id}`;
+            // Skip if already processed
+            if (processedTxns.current.has(operationKey)) {
+                console.log(`[trails-sdk] MetaTxn ${operationKey}: Already processed, skipping`);
+                return;
+            }
+            const monitorStatus = metaTxnMonitorStatuses[operationKey];
+            if (!monitorStatus || monitorStatus.status !== "confirmed") {
+                console.log(`[trails-sdk] MetaTxn ${operationKey}: Status not confirmed, skipping`);
+                return;
+            }
+            // Type assertion since we know it exists when status is "confirmed"
+            const transactionHash = monitorStatus.transactionHash;
+            if (!transactionHash) {
+                console.log(`[trails-sdk] MetaTxn ${operationKey}: No transaction hash, skipping`);
+                return;
+            }
+            console.log(`[trails-sdk] MetaTxn ${operationKey}: Processing transaction ${transactionHash}`);
+            processedTxns.current.add(operationKey);
+            try {
+                const chainId = parseInt(metaTxn.chainId);
+                if (Number.isNaN(chainId) || chainId <= 0) {
+                    throw new Error(`Invalid chainId for meta transaction: ${metaTxn.chainId}`);
+                }
+                const chainConfig = getChainInfo(chainId);
+                const client = createPublicClient({
+                    chain: chainConfig,
+                    transport: http(),
+                });
+                const receipt = await client.getTransactionReceipt({
+                    hash: transactionHash,
+                });
+                if (receipt && typeof receipt.blockNumber === "bigint") {
+                    const block = await client.getBlock({
+                        blockNumber: receipt.blockNumber,
+                    });
+                    console.log(`[trails-sdk] MetaTxn ${operationKey}: Got block timestamp ${block.timestamp}`);
+                    setMetaTxnBlockTimestamps((prev) => ({
+                        ...prev,
+                        [operationKey]: {
+                            timestamp: Number(block.timestamp),
+                            error: undefined,
+                        },
+                    }));
+                }
+                else {
+                    console.warn(`[trails-sdk] MetaTxn ${operationKey}: No block number in receipt`);
+                    setMetaTxnBlockTimestamps((prev) => ({
+                        ...prev,
+                        [operationKey]: {
+                            timestamp: null,
+                            error: "Block number not found in receipt",
+                        },
+                    }));
+                }
+            }
+            catch (error) {
+                console.error(`[trails-sdk] MetaTxn ${operationKey}: Error:`, error);
+                setMetaTxnBlockTimestamps((prev) => ({
+                    ...prev,
+                    [operationKey]: {
+                        timestamp: null,
+                        error: error.message || "Failed to fetch receipt/timestamp",
+                    },
+                }));
+            }
+        });
+    }, [metaTxns, metaTxnMonitorStatuses, metaTxnBlockTimestamps]);
+    const updateAutoExecute = (enabled) => {
+        setIsAutoExecute(enabled);
+    };
+    function createIntent(args) {
+        createIntentMutation.mutate({
+            ...args,
+            destinationSalt: Date.now().toString(),
+        });
+    }
+    function commitIntentConfig(args) {
+        console.log("[trails-sdk] commitIntentConfig", args);
+        commitIntentConfigMutation.mutate(args);
+    }
+    function updateOriginCallParams(args) {
+        if (!args) {
+            setOriginCallParams(null);
+            return;
+        }
+        const { originChainId, tokenAddress } = args;
+        setOriginChainId(originChainId);
+        setTokenAddress(tokenAddress);
+    }
+    function sendMetaTxn(selectedId) {
+        sendMetaTxnMutation.mutate({ selectedId });
+    }
+    const { chainId } = account;
+    const originChainIdFromParams = originCallParams?.chainId;
+    const createIntentPending = createIntentMutation.isPending;
+    const createIntentSuccess = createIntentMutation.isSuccess;
+    const createIntentError = createIntentMutation.error;
+    const createIntentArgs = createIntentMutation.variables;
+    const commitIntentConfigPending = commitIntentConfigMutation.isPending;
+    const commitIntentConfigSuccess = commitIntentConfigMutation.isSuccess;
+    const commitIntentConfigError = commitIntentConfigMutation.error;
+    const commitIntentConfigArgs = commitIntentConfigMutation.variables;
+    const sendMetaTxnPending = sendMetaTxnMutation.isPending;
+    const sendMetaTxnSuccess = sendMetaTxnMutation.isSuccess;
+    const sendMetaTxnError = sendMetaTxnMutation.error;
+    const sendMetaTxnArgs = sendMetaTxnMutation.variables;
+    return {
+        apiClient,
+        metaTxns,
+        intentCallsPayloads,
+        intentPreconditions,
+        trailsFee,
+        txnHash,
+        committedOriginIntentAddress,
+        committedDestinationIntentAddress,
+        verificationStatus,
+        getRelayer,
+        estimatedGas,
+        isEstimateError,
+        estimateError,
+        calculateIntentAddress,
+        calculateOriginAndDestinationIntentAddresses,
+        committedIntentConfig,
+        isLoadingCommittedConfig,
+        committedConfigError,
+        commitIntentConfig,
+        commitIntentConfigPending,
+        commitIntentConfigSuccess,
+        commitIntentConfigError,
+        commitIntentConfigArgs,
+        getIntentCallsPayloads,
+        operationHashes,
+        callIntentCallsPayload,
+        sendOriginTransaction,
+        switchChain,
+        isSwitchingChain,
+        switchChainError,
+        isTransactionInProgress,
+        isChainSwitchRequired: chainId !== originChainIdFromParams && !!originChainIdFromParams,
+        sendTransaction: sendOriginTxn.sendTransaction,
+        isSendingTransaction: sendOriginTxn.isPending,
+        originCallStatus,
+        updateOriginCallStatus,
+        isEstimatingGas,
+        isAutoExecute,
+        updateAutoExecute,
+        receipt,
+        isWaitingForReceipt,
+        receiptIsSuccess,
+        receiptIsError,
+        receiptError,
+        hasAutoExecuted,
+        originCallSuccess: sendOriginTxn.isSuccess,
+        sentMetaTxns,
+        sendMetaTxn,
+        sendMetaTxnPending,
+        sendMetaTxnSuccess,
+        sendMetaTxnError,
+        sendMetaTxnArgs,
+        clearIntent,
+        metaTxnMonitorStatuses,
+        createIntent,
+        createIntentPending,
+        createIntentSuccess,
+        createIntentError,
+        createIntentArgs,
+        originCallParams,
+        updateOriginCallParams,
+        originBlockTimestamp,
+        metaTxnBlockTimestamps,
+        originIntentAddress,
+        destinationIntentAddress,
+    };
+}