0xtrails 0.0.1 → 0.0.2

package/dist/prices.d.ts

@@ -0,0 +1,18 @@
+import type { SequenceAPIClient, Token, TokenPrice } from "@0xsequence/trails-api";
+export declare const fetchGetTokenPrices: (apiClient: SequenceAPIClient, tokens: Token[]) => Promise<TokenPrice[]>;
+export declare function normalizeToken(token: Token & {
+    tokenID?: string;
+    symbol?: string;
+}): Token;
+export declare const getTokenPrices: (apiClient: SequenceAPIClient, tokens: Token[]) => Promise<TokenPrice[]>;
+export declare const getTokenPrice: (apiClient: SequenceAPIClient, token: Token) => Promise<TokenPrice | null>;
+export declare const useTokenPrices: (tokens: Token[], apiClient: SequenceAPIClient) => {
+    tokenPrices: TokenPrice[] | undefined;
+    isLoadingTokenPrices: boolean;
+};
+export declare const useTokenPrice: (token?: Token | null, apiClient?: SequenceAPIClient) => {
+    tokenPrice: TokenPrice | null | undefined;
+    isLoadingTokenPrice: boolean;
+};
+export declare function invalidateTokenPricesCache(token?: Token): void;
+//# sourceMappingURL=prices.d.ts.map

package/dist/prices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prices.d.ts","sourceRoot":"","sources":["../src/prices.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,KAAK,EACL,UAAU,EACX,MAAM,wBAAwB,CAAA;AAyE/B,eAAO,MAAM,mBAAmB,GAC9B,WAAW,iBAAiB,EAC5B,QAAQ,KAAK,EAAE,KACd,OAAO,CAAC,UAAU,EAAE,CAgBtB,CAAA;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,KAAK,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACnD,KAAK,CAMP;AAED,eAAO,MAAM,cAAc,GACzB,WAAW,iBAAiB,EAC5B,QAAQ,KAAK,EAAE,KACd,OAAO,CAAC,UAAU,EAAE,CAQtB,CAAA;AAED,eAAO,MAAM,aAAa,GACxB,WAAW,iBAAiB,EAC5B,OAAO,KAAK,KACX,OAAO,CAAC,UAAU,GAAG,IAAI,CAS3B,CAAA;AAED,eAAO,MAAM,cAAc,GACzB,QAAQ,KAAK,EAAE,EACf,WAAW,iBAAiB;;;CAe7B,CAAA;AAED,eAAO,MAAM,aAAa,GACxB,QAAQ,KAAK,GAAG,IAAI,EACpB,YAAY,iBAAiB;;;CAc9B,CAAA;AAGD,wBAAgB,0BAA0B,CAAC,KAAK,CAAC,EAAE,KAAK,QAYvD"}

package/dist/prices.js

@@ -0,0 +1,142 @@
+import { QueryClient, useQuery } from "@tanstack/react-query";
+import { zeroAddress } from "viem";
+// Global caching configuration
+const CACHE_CONFIG = {
+    // Time configurations
+    staleTime: 30000, // 30 seconds - prices change frequently
+    gcTime: 120000, // 2 minutes cache time
+    refetchInterval: 60000, // Background refetch every minute for prices
+    // Retry configurations
+    retry: 2,
+    retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
+    // Refetch behaviors
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: true,
+    refetchIntervalInBackground: true,
+    // Retry logic for specific error types
+    shouldRetry: (failureCount, error) => {
+        if (error && "status" in error && error.status === 404)
+            return false;
+        if (failureCount < 2)
+            return true;
+        return false;
+    },
+};
+// Extract common query options for reuse
+const COMMON_QUERY_OPTIONS = {
+    staleTime: CACHE_CONFIG.staleTime,
+    gcTime: CACHE_CONFIG.gcTime,
+    retry: CACHE_CONFIG.shouldRetry,
+    retryDelay: CACHE_CONFIG.retryDelay,
+    refetchOnWindowFocus: CACHE_CONFIG.refetchOnWindowFocus,
+    refetchOnReconnect: CACHE_CONFIG.refetchOnReconnect,
+    refetchInterval: CACHE_CONFIG.refetchInterval,
+    refetchIntervalInBackground: CACHE_CONFIG.refetchIntervalInBackground,
+};
+// Initialize query client for token prices
+const tokenPricesQueryClient = new QueryClient({
+    defaultOptions: {
+        queries: {
+            ...COMMON_QUERY_OPTIONS,
+            // Override retry for QueryClient (use number instead of function)
+            retry: CACHE_CONFIG.retry,
+        },
+    },
+});
+// Cache key generation methods
+const createTokenCacheKey = (token) => {
+    return `${token.contractAddress}-${token.chainId}-${token.tokenId}`;
+};
+const createBatchCacheKey = (tokens) => {
+    return [
+        "tokenPrices",
+        "batch",
+        tokens.length,
+        tokens.map(createTokenCacheKey).sort(),
+    ];
+};
+const createSingleCacheKey = (token) => {
+    return ["tokenPrices", "single", token ? createTokenCacheKey(token) : null];
+};
+// Separate fetch function for token prices
+export const fetchGetTokenPrices = async (apiClient, tokens) => {
+    if (!apiClient) {
+        throw new Error("API client is required");
+    }
+    if (tokens.length === 0) {
+        return [];
+    }
+    try {
+        const res = await apiClient.getCoinPrices({ tokens });
+        return res?.tokenPrices || [];
+    }
+    catch (error) {
+        console.error("[trails-sdk] Failed to fetch token prices:", error);
+        throw error;
+    }
+};
+export function normalizeToken(token) {
+    return {
+        chainId: token.chainId,
+        contractAddress: token.contractAddress || zeroAddress,
+        tokenId: token.tokenId || token.tokenID || token.symbol,
+    };
+}
+export const getTokenPrices = async (apiClient, tokens) => {
+    tokens = tokens.map(normalizeToken);
+    return tokenPricesQueryClient.fetchQuery({
+        queryKey: createBatchCacheKey(tokens),
+        queryFn: () => fetchGetTokenPrices(apiClient, tokens),
+        ...COMMON_QUERY_OPTIONS,
+    });
+};
+export const getTokenPrice = async (apiClient, token) => {
+    return tokenPricesQueryClient.fetchQuery({
+        queryKey: createSingleCacheKey(token),
+        queryFn: async () => {
+            const prices = await getTokenPrices(apiClient, [token]);
+            return prices?.length ? prices[0] : null;
+        },
+        ...COMMON_QUERY_OPTIONS,
+    });
+};
+export const useTokenPrices = (tokens, apiClient) => {
+    tokens = tokens.map(normalizeToken);
+    const { data: tokenPrices, isLoading: isLoadingTokenPrices } = useQuery({
+        queryKey: createBatchCacheKey(tokens),
+        queryFn: () => getTokenPrices(apiClient, tokens),
+        enabled: tokens.length > 0 && !!apiClient,
+        ...COMMON_QUERY_OPTIONS,
+    });
+    return {
+        tokenPrices,
+        isLoadingTokenPrices,
+    };
+};
+export const useTokenPrice = (token, apiClient) => {
+    const { data: tokenPrice, isLoading: isLoadingTokenPrice } = useQuery({
+        queryKey: createSingleCacheKey(token),
+        queryFn: () => token && apiClient ? getTokenPrice(apiClient, token) : null,
+        enabled: !!token && !!apiClient,
+        ...COMMON_QUERY_OPTIONS,
+    });
+    return {
+        tokenPrice,
+        isLoadingTokenPrice,
+    };
+};
+// Cache invalidation utility function
+export function invalidateTokenPricesCache(token) {
+    if (token) {
+        // Invalidate specific token price using consistent cache key
+        tokenPricesQueryClient.invalidateQueries({
+            queryKey: createSingleCacheKey(token),
+        });
+    }
+    else {
+        // Invalidate all token price queries
+        tokenPricesQueryClient.invalidateQueries({
+            queryKey: ["tokenPrices"],
+        });
+    }
+}

package/dist/queryParams.d.ts

@@ -0,0 +1,9 @@
+export declare function getQueryParam(key: string): string | null;
+export declare function useQueryParams(): {
+    queryParams: URLSearchParams;
+    getParam: (key: string) => string | null;
+    hasParam: (key: string, value?: string) => boolean;
+    setParam: (key: string, value: string) => void;
+    removeParam: (key: string) => void;
+};
+//# sourceMappingURL=queryParams.d.ts.map

package/dist/queryParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryParams.d.ts","sourceRoot":"","sources":["../src/queryParams.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGxD;AAED,wBAAgB,cAAc;;oBAsCL,MAAM,KAAG,MAAM,GAAG,IAAI;oBAItB,MAAM,UAAU,MAAM,KAAG,OAAO;oBAKhC,MAAM,SAAS,MAAM;uBASlB,MAAM;EAgBjC"}

package/dist/queryParams.js

@@ -0,0 +1,66 @@
+import { useEffect, useState } from "react";
+export function getQueryParam(key) {
+    if (typeof window === "undefined")
+        return null;
+    return new URLSearchParams(window.location.search).get(key);
+}
+export function useQueryParams() {
+    const [queryParams, setQueryParams] = useState(typeof window !== "undefined"
+        ? new URLSearchParams(window.location.search)
+        : new URLSearchParams());
+    useEffect(() => {
+        const updateQueryParams = () => {
+            setQueryParams(new URLSearchParams(window.location.search));
+        };
+        // Check on popstate (back/forward navigation)
+        window.addEventListener("popstate", updateQueryParams);
+        // Check on pushState/replaceState
+        const originalPushState = window.history.pushState;
+        const originalReplaceState = window.history.replaceState;
+        window.history.pushState = function () {
+            // biome-ignore lint/complexity/noArguments: TODO: To fix
+            originalPushState.apply(this, arguments);
+            updateQueryParams();
+        };
+        window.history.replaceState = function () {
+            // biome-ignore lint/complexity/noArguments: TODO: To fix
+            originalReplaceState.apply(this, arguments);
+            updateQueryParams();
+        };
+        return () => {
+            window.removeEventListener("popstate", updateQueryParams);
+            window.history.pushState = originalPushState;
+            window.history.replaceState = originalReplaceState;
+        };
+    }, []);
+    const getParam = (key) => {
+        return queryParams.get(key);
+    };
+    const hasParam = (key, value) => {
+        const result = value ? queryParams.get(key) === value : queryParams.has(key);
+        return result;
+    };
+    const setParam = (key, value) => {
+        const newParams = new URLSearchParams(queryParams);
+        newParams.set(key, value);
+        const url = new URL(window.location.href);
+        url.search = newParams.toString();
+        window.history.pushState({}, "", url.toString());
+        setQueryParams(newParams);
+    };
+    const removeParam = (key) => {
+        const newParams = new URLSearchParams(queryParams);
+        newParams.delete(key);
+        const url = new URL(window.location.href);
+        url.search = newParams.toString();
+        window.history.pushState({}, "", url.toString());
+        setQueryParams(newParams);
+    };
+    return {
+        queryParams,
+        getParam,
+        hasParam,
+        setParam,
+        removeParam,
+    };
+}

package/dist/relaySdk.d.ts

@@ -0,0 +1,65 @@
+import type { WalletClient } from "viem";
+export type Chain = any;
+export type RelayQuote = any;
+export type RelayExecuteResult = any;
+export type RelayProgressData = any;
+export interface RelayQuoteOptions {
+    wallet: WalletClient;
+    chainId: number;
+    toChainId?: number;
+    amount: string;
+    currency: string;
+    toCurrency?: string;
+    tradeType?: "EXACT_INPUT" | "EXACT_OUTPUT";
+    txs: Array<{
+        to: string;
+        value: string;
+        data: string;
+    }>;
+    recipient?: string;
+}
+export interface RelayExecuteOptions {
+    quote: RelayQuote;
+    wallet: WalletClient;
+    onProgress?: (data: RelayProgressData) => void;
+}
+/**
+ * Get a quote for a relay transaction
+ */
+export declare function getRelaySDKQuote(options: RelayQuoteOptions): Promise<RelayQuote>;
+/**
+ * Execute a relay transaction
+ */
+export declare function relaySDKExecute(options: RelayExecuteOptions): Promise<RelayExecuteResult>;
+/**
+ * Helper function to create a simple relay transaction for a contract call
+ */
+export declare function createSimpleRelayTransaction(wallet: WalletClient, contractAddress: string, callData: string, value: string, chainId: number, currency?: string): Promise<RelayQuote>;
+/**
+ * Helper function to execute a simple relay transaction
+ */
+export declare function executeSimpleRelayTransaction(quote: RelayQuote, wallet: WalletClient, onProgress?: RelayExecuteOptions["onProgress"]): Promise<RelayExecuteResult>;
+export declare function getTxHashFromRelayResult(result: RelayExecuteResult): string;
+export declare const relaySupportedChains: Record<number, Chain>;
+export declare function getRelaySupportedChains(): Promise<Chain[]>;
+export declare function isChainSupported(chainId: number): Promise<boolean>;
+export interface RelayToken {
+    id: string;
+    symbol: string;
+    name: string;
+    contractAddress: string;
+    decimals: number;
+    chainId: number;
+    chainName: string;
+    imageUrl: string;
+}
+export declare function getRelaySupportedTokens(): Promise<RelayToken[]>;
+export type GetIsRouteSupportedOptions = {
+    originChainId: number;
+    destinationChainId: number;
+    amount: string;
+    originToken: string;
+    destinationToken: string;
+};
+export declare function getIsRouteSupported({ originChainId, destinationChainId, amount, originToken, destinationToken, }: GetIsRouteSupportedOptions): Promise<boolean>;
+//# sourceMappingURL=relaySdk.d.ts.map

package/dist/relaySdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relaySdk.d.ts","sourceRoot":"","sources":["../src/relaySdk.ts"],"names":[],"mappings":"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"}

package/dist/relaySdk.js

@@ -0,0 +1,314 @@
+import { convertViemChainToRelayChain, createClient, getClient, MAINNET_RELAY_API, } from "@reservoir0x/relay-sdk";
+import * as chains from "viem/chains";
+createClient({
+    baseApiUrl: MAINNET_RELAY_API,
+    source: "Trails",
+    chains: Object.values(chains).map((chain) => convertViemChainToRelayChain(chain)),
+});
+/**
+ * Get a quote for a relay transaction
+ */
+export async function getRelaySDKQuote(options) {
+    try {
+        const client = getClient();
+        if (!client) {
+            throw new Error("Relay client not available");
+        }
+        console.log("[trails-sdk] getRelaySDKQuote", options);
+        const quote = await client.actions.getQuote({
+            wallet: options.wallet,
+            chainId: options.chainId,
+            toChainId: options.toChainId || options.chainId,
+            amount: options.amount,
+            currency: options.currency,
+            toCurrency: options.toCurrency || options.currency,
+            tradeType: options.tradeType || "EXACT_OUTPUT",
+            txs: options.txs,
+            user: options.wallet.account.address,
+            recipient: options.recipient || options.wallet.account.address,
+        });
+        return quote;
+    }
+    catch (error) {
+        console.error("[trails-sdk] Error getting relay quote:", error);
+        throw error;
+    }
+}
+/**
+ * Execute a relay transaction
+ */
+export async function relaySDKExecute(options) {
+    try {
+        const client = getClient();
+        if (!client) {
+            throw new Error("Relay client not available");
+        }
+        console.log("[trails-sdk] relaysdkclient", client.chains, options.quote);
+        const result = await client.actions.execute({
+            quote: options.quote,
+            wallet: options.wallet,
+            onProgress: options.onProgress ||
+                ((data) => {
+                    console.log("[trails-sdk] Relay progress:", data);
+                }),
+        });
+        return result;
+    }
+    catch (error) {
+        console.error("[trails-sdk] Error executing relay transaction:", error);
+        throw error;
+    }
+}
+/**
+ * Helper function to create a simple relay transaction for a contract call
+ */
+export async function createSimpleRelayTransaction(wallet, contractAddress, callData, value, chainId, currency = "0x0000000000000000000000000000000000000000") {
+    const options = {
+        wallet,
+        chainId,
+        amount: value,
+        currency,
+        txs: [
+            {
+                to: contractAddress,
+                value,
+                data: callData,
+            },
+        ],
+    };
+    return await getRelaySDKQuote(options);
+}
+/**
+ * Helper function to execute a simple relay transaction
+ */
+export async function executeSimpleRelayTransaction(quote, wallet, onProgress) {
+    return await relaySDKExecute({
+        quote,
+        wallet,
+        onProgress,
+    });
+}
+export function getTxHashFromRelayResult(result) {
+    return result?.data?.steps?.[result?.data?.steps.length - 1]?.items?.[0]
+        ?.txHashes?.[0]?.txHash;
+}
+// Source: https://docs.relay.link/resources/supported-chains
+export const relaySupportedChains = {
+    [chains.abstract.id]: chains.abstract,
+    [chains.ancient8.id]: chains.ancient8,
+    [chains.apeChain.id]: chains.apeChain,
+    [chains.arbitrum.id]: chains.arbitrum,
+    [chains.arbitrumNova.id]: chains.arbitrumNova,
+    [chains.arenaz.id]: chains.arenaz,
+    [chains.avalanche.id]: chains.avalanche,
+    [chains.b3.id]: chains.b3,
+    [chains.base.id]: chains.base,
+    [chains.berachain.id]: chains.berachain,
+    [chains.blast.id]: chains.blast,
+    [chains.opBNB.id]: chains.opBNB,
+    [chains.bob.id]: chains.bob,
+    [chains.boba.id]: chains.boba,
+    [chains.celo.id]: chains.celo,
+    [chains.corn.id]: chains.corn,
+    [chains.cronos.id]: chains.cronos,
+    [chains.cyber.id]: chains.cyber,
+    [chains.degen.id]: chains.degen,
+    [chains.mainnet.id]: chains.mainnet,
+    [chains.flowMainnet.id]: chains.flowMainnet,
+    [chains.forma.id]: chains.forma,
+    [chains.funkiMainnet.id]: chains.funkiMainnet,
+    [chains.gnosis.id]: chains.gnosis,
+    [chains.gravity.id]: chains.gravity,
+    [chains.hemi.id]: chains.hemi,
+    [chains.hychain.id]: chains.hychain,
+    [chains.ink.id]: chains.ink,
+    [chains.linea.id]: chains.linea,
+    [chains.lisk.id]: chains.lisk,
+    [chains.manta.id]: chains.manta,
+    [chains.mantle.id]: chains.mantle,
+    [chains.metis.id]: chains.metis,
+    [chains.mint.id]: chains.mint,
+    [chains.mode.id]: chains.mode,
+    [chains.morph.id]: chains.morph,
+    [chains.optimism.id]: chains.optimism,
+    [chains.plume.id]: chains.plume,
+    [chains.polygon.id]: chains.polygon,
+    [chains.polygonZkEvm.id]: chains.polygonZkEvm,
+    [chains.ronin.id]: chains.ronin,
+    [chains.redstone.id]: chains.redstone,
+    [chains.sanko.id]: chains.sanko,
+    [chains.scroll.id]: chains.scroll,
+    [chains.sei.id]: chains.sei,
+    [chains.shape.id]: chains.shape,
+    [chains.soneium.id]: chains.soneium,
+    [chains.sonic.id]: chains.sonic,
+    [chains.story.id]: chains.story,
+    [chains.superposition.id]: chains.superposition,
+    [chains.superseed.id]: chains.superseed,
+    [chains.swellchain.id]: chains.swellchain,
+    [chains.taiko.id]: chains.taiko,
+    [chains.tron.id]: chains.tron,
+    [chains.unichain.id]: chains.unichain,
+    [chains.worldchain.id]: chains.worldchain,
+    [chains.xai.id]: chains.xai,
+    [chains.zeroG.id]: chains.zeroG,
+    [chains.zircuit.id]: chains.zircuit,
+    [chains.zksync.id]: chains.zksync,
+    [chains.zora.id]: chains.zora,
+};
+export async function getRelaySupportedChains() {
+    return Object.values(relaySupportedChains);
+}
+export async function isChainSupported(chainId) {
+    return Object.keys(relaySupportedChains).includes(chainId.toString());
+}
+export async function getRelaySupportedTokens() {
+    try {
+        const chains = await fetchRelayChains();
+        const tokens = [];
+        chains.forEach((chain) => {
+            if (!chain.disabled) {
+                // Add native currency
+                tokens.push({
+                    id: chain.currency.id,
+                    symbol: chain.currency.symbol,
+                    name: chain.currency.name,
+                    contractAddress: chain.currency.address,
+                    decimals: chain.currency.decimals,
+                    chainId: chain.id,
+                    chainName: chain.displayName || chain.name,
+                    imageUrl: "", // Native currencies typically don't have logoURI
+                });
+                // Add featured tokens
+                chain.featuredTokens.forEach((token) => {
+                    tokens.push({
+                        id: token.id,
+                        symbol: token.symbol,
+                        name: token.name,
+                        contractAddress: token.address,
+                        decimals: token.decimals,
+                        chainId: chain.id,
+                        chainName: chain.displayName || chain.name,
+                        imageUrl: token.metadata?.logoURI || "",
+                    });
+                });
+                // Add ERC20 currencies
+                chain.erc20Currencies.forEach((token) => {
+                    tokens.push({
+                        id: token.id,
+                        symbol: token.symbol,
+                        name: token.name,
+                        contractAddress: token.address,
+                        decimals: token.decimals,
+                        chainId: chain.id,
+                        chainName: chain.displayName || chain.name,
+                        imageUrl: token.metadata?.logoURI || "",
+                    });
+                });
+                // Add solver currencies (fallback for chains that might not have featuredTokens/erc20Currencies)
+                chain.solverCurrencies.forEach((token) => {
+                    tokens.push({
+                        id: token.id,
+                        symbol: token.symbol,
+                        name: token.name,
+                        contractAddress: token.address,
+                        decimals: token.decimals,
+                        chainId: chain.id,
+                        chainName: chain.displayName || chain.name,
+                        imageUrl: token.metadata?.logoURI || "",
+                    });
+                });
+            }
+        });
+        // Remove duplicates by chainId and contractAddress
+        const uniqueTokens = tokens.filter((token, index, self) => index ===
+            self.findIndex((t) => t.chainId === token.chainId &&
+                t.contractAddress.toLowerCase() ===
+                    token.contractAddress.toLowerCase()));
+        console.log(`[trails-sdk] Fetched ${uniqueTokens.length} unique tokens from Relay API`);
+        return uniqueTokens;
+    }
+    catch (error) {
+        console.error("[trails-sdk] Error fetching Relay supported tokens:", error);
+        return [];
+    }
+}
+// Cache for chains data
+let cachedChains = null;
+let cacheTimestamp = 0;
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+async function fetchRelayChains() {
+    const now = Date.now();
+    // Return cached data if still valid
+    if (cachedChains && now - cacheTimestamp < CACHE_DURATION) {
+        return cachedChains;
+    }
+    try {
+        const response = await fetch("https://api.relay.link/chains");
+        if (!response.ok) {
+            throw new Error(`Failed to fetch chains: ${response.status}`);
+        }
+        const data = await response.json();
+        cachedChains = data.chains;
+        cacheTimestamp = now;
+        return data.chains;
+    }
+    catch (error) {
+        console.error("[trails-sdk] Error fetching Relay chains:", error);
+        // Return cached data if available, even if expired
+        if (cachedChains) {
+            return cachedChains;
+        }
+        throw error;
+    }
+}
+export async function getIsRouteSupported({ originChainId, destinationChainId, amount, originToken, destinationToken, }) {
+    try {
+        // Fetch supported chains from Relay API
+        const chains = await fetchRelayChains();
+        // Check if both chains are supported and not disabled
+        const originChain = chains.find((chain) => chain.id === originChainId);
+        const destinationChain = chains.find((chain) => chain.id === destinationChainId);
+        if (!originChain ||
+            !destinationChain ||
+            originChain.disabled ||
+            destinationChain.disabled) {
+            return false;
+        }
+        // Check if destination token is supported on destination chain
+        const isDestinationTokenSupported = destinationChain.solverCurrencies.some((currency) => currency.address.toLowerCase() === destinationToken.toLowerCase());
+        if (!isDestinationTokenSupported) {
+            return false;
+        }
+        // If we have a client available, try to get a quote to verify the route
+        const client = getClient();
+        if (client) {
+            try {
+                const sender = "0x1111111111111111111111111111111111111111";
+                const quote = await client.actions.getQuote({
+                    chainId: originChainId,
+                    toChainId: destinationChainId,
+                    amount: amount,
+                    currency: originToken,
+                    toCurrency: destinationToken,
+                    tradeType: "EXACT_OUTPUT",
+                    txs: [],
+                    user: sender,
+                    recipient: sender,
+                });
+                return quote.steps.length > 0;
+            }
+            catch (error) {
+                console.warn("[trails-sdk] Quote check failed, falling back to chain/token validation:", error);
+                // If quote fails, we still return true if chains and tokens are supported
+                return true;
+            }
+        }
+        // If no client available, return true if chains and tokens are supported
+        return true;
+    }
+    catch (error) {
+        console.error("[trails-sdk] Error checking route support:", error);
+        return false;
+    }
+}

package/dist/relayer.d.ts

@@ -0,0 +1,23 @@
+import { Relayer } from "@0xsequence/wallet-core";
+export type RelayerOperationStatus = Relayer.OperationStatus;
+export type RpcRelayer = Relayer.Standard.Rpc.RpcRelayer;
+export type RelayerConfig = {
+    hostname: string;
+    chainId: number;
+    rpcUrl: string;
+};
+export type RelayerEnv = "local" | "cors-anywhere" | "dev" | "prod";
+export type RelayerEnvConfig = {
+    env?: RelayerEnv;
+    useV3Relayers?: boolean;
+};
+export type { Relayer };
+export declare function getBackupRelayer(chainId: number): Relayer.Standard.Rpc.RpcRelayer | undefined;
+export declare function getRelayerUrl(config: RelayerEnvConfig, chainId: number): string;
+export declare function getRelayer(config: RelayerEnvConfig, chainId: number): Relayer.Standard.Rpc.RpcRelayer;
+export declare function useRelayers(config?: RelayerEnvConfig): {
+    relayers: Map<number, Relayer.Standard.Rpc.RpcRelayer>;
+    getRelayer: (chainId: number) => Relayer.Standard.Rpc.RpcRelayer;
+    getBackupRelayer: (chainId: number) => Relayer.Standard.Rpc.RpcRelayer | undefined;
+};
+//# sourceMappingURL=relayer.d.ts.map

package/dist/relayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relayer.d.ts","sourceRoot":"","sources":["../src/relayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AAMjD,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,eAAe,CAAA;AAC5D,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAA;AAExD,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,eAAe,GAAG,KAAK,GAAG,MAAM,CAAA;AAEnE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,CAAC,EAAE,UAAU,CAAA;IAChB,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED,YAAY,EAAE,OAAO,EAAE,CAAA;AAEvB,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,GAAG,SAAS,CAgB7C;AAGD,wBAAgB,aAAa,CAC3B,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,MAAM,GACd,MAAM,CAsJR;AAED,wBAAgB,UAAU,CACxB,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAejC;AAED,wBAAgB,WAAW,CACzB,MAAM,GAAE,gBAEP,GACA;IACD,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IACtD,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAA;IAChE,gBAAgB,EAAE,CAChB,OAAO,EAAE,MAAM,KACZ,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,GAAG,SAAS,CAAA;CACjD,CAwBA"}