diff --git a/.gitignore b/.gitignore
index 3fabf7c..7018024 100644
--- a/.gitignore
+++ b/.gitignore
@@ -49,3 +49,7 @@ next-env.d.ts
 .agent/
 /documentation/
 /inspiration/
+provider-logs/
+
+# Local planning/specs — never commit
+docs/
diff --git a/src/app/api/quotes/route.ts b/src/app/api/quotes/route.ts
index b4df421..a87cdb4 100644
--- a/src/app/api/quotes/route.ts
+++ b/src/app/api/quotes/route.ts
@@ -11,6 +11,7 @@ const quoteSchema = z.object({
   fromAddress: z.string().optional(),
   toAddress: z.string().optional(),
   fromTokenDecimals: z.number().optional(),
+  toTokenDecimals: z.number().optional(),
 })
 
 export async function POST(request: Request) {
@@ -31,10 +32,12 @@ export async function POST(request: Request) {
       fromTokenDecimals: params.fromTokenDecimals,
     })
 
-    return NextResponse.json({ 
-      success: true, 
+    return NextResponse.json({
+      success: true,
       routes: result.quotes,
       bestQuote: result.bestQuote,
+      unsupported: result.unsupported ?? false,
+      reason: result.reason,
       expiresAt: result.expiresAt,
       fetchedAt: result.fetchedAt,
       providerStats: result.providerStats,
diff --git a/src/components/Dither.tsx b/src/components/Dither.tsx
deleted file mode 100644
index f01cbc3..0000000
--- a/src/components/Dither.tsx
+++ /dev/null
@@ -1,333 +0,0 @@
-import { useRef, useState, useEffect, forwardRef } from 'react';
-import { Canvas, useFrame, useThree, ThreeEvent } from '@react-three/fiber';
-import { EffectComposer, wrapEffect } from '@react-three/postprocessing';
-import { Effect } from 'postprocessing';
-import * as THREE from 'three';
-
-const waveVertexShader = `
-precision highp float;
-varying vec2 vUv;
-void main() {
-  vUv = uv;
-  vec4 modelPosition = modelMatrix * vec4(position, 1.0);
-  vec4 viewPosition = viewMatrix * modelPosition;
-  gl_Position = projectionMatrix * viewPosition;
-}
-`;
-
-const waveFragmentShader = `
-precision highp float;
-uniform vec2 resolution;
-uniform float time;
-uniform float waveSpeed;
-uniform float waveFrequency;
-uniform float waveAmplitude;
-uniform vec3 waveColor;
-uniform vec2 mousePos;
-uniform int enableMouseInteraction;
-uniform float mouseRadius;
-
-vec4 mod289(vec4 x) { return x - floor(x * (1.0/289.0)) * 289.0; }
-vec4 permute(vec4 x) { return mod289(((x * 34.0) + 1.0) * x); }
-vec4 taylorInvSqrt(vec4 r) { return 1.79284291400159 - 0.85373472095314 * r; }
-vec2 fade(vec2 t) { return t*t*t*(t*(t*6.0-15.0)+10.0); }
-
-float cnoise(vec2 P) {
-  vec4 Pi = floor(P.xyxy) + vec4(0.0,0.0,1.0,1.0);
-  vec4 Pf = fract(P.xyxy) - vec4(0.0,0.0,1.0,1.0);
-  Pi = mod289(Pi);
-  vec4 ix = Pi.xzxz;
-  vec4 iy = Pi.yyww;
-  vec4 fx = Pf.xzxz;
-  vec4 fy = Pf.yyww;
-  vec4 i = permute(permute(ix) + iy);
-  vec4 gx = fract(i * (1.0/41.0)) * 2.0 - 1.0;
-  vec4 gy = abs(gx) - 0.5;
-  vec4 tx = floor(gx + 0.5);
-  gx = gx - tx;
-  vec2 g00 = vec2(gx.x, gy.x);
-  vec2 g10 = vec2(gx.y, gy.y);
-  vec2 g01 = vec2(gx.z, gy.z);
-  vec2 g11 = vec2(gx.w, gy.w);
-  vec4 norm = taylorInvSqrt(vec4(dot(g00,g00), dot(g01,g01), dot(g10,g10), dot(g11,g11)));
-  g00 *= norm.x; g01 *= norm.y; g10 *= norm.z; g11 *= norm.w;
-  float n00 = dot(g00, vec2(fx.x, fy.x));
-  float n10 = dot(g10, vec2(fx.y, fy.y));
-  float n01 = dot(g01, vec2(fx.z, fy.z));
-  float n11 = dot(g11, vec2(fx.w, fy.w));
-  vec2 fade_xy = fade(Pf.xy);
-  vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
-  return 2.3 * mix(n_x.x, n_x.y, fade_xy.y);
-}
-
-const int OCTAVES = 4;
-float fbm(vec2 p) {
-  float value = 0.0;
-  float amp = 1.0;
-  float freq = waveFrequency;
-  for (int i = 0; i < OCTAVES; i++) {
-    value += amp * abs(cnoise(p));
-    p *= freq;
-    amp *= waveAmplitude;
-  }
-  return value;
-}
-
-float pattern(vec2 p) {
-  vec2 p2 = p - time * waveSpeed;
-  return fbm(p + fbm(p2)); 
-}
-
-void main() {
-  vec2 uv = gl_FragCoord.xy / resolution.xy;
-  uv -= 0.5;
-  uv.x *= resolution.x / resolution.y;
-  float f = pattern(uv);
-  if (enableMouseInteraction == 1) {
-    vec2 mouseNDC = (mousePos / resolution - 0.5) * vec2(1.0, -1.0);
-    mouseNDC.x *= resolution.x / resolution.y;
-    float dist = length(uv - mouseNDC);
-    float effect = 1.0 - smoothstep(0.0, mouseRadius, dist);
-    f -= 0.5 * effect;
-  }
-  vec3 col = mix(vec3(0.0), waveColor, f);
-  gl_FragColor = vec4(col, 1.0);
-}
-`;
-
-const ditherFragmentShader = `
-precision highp float;
-uniform float colorNum;
-uniform float pixelSize;
-const float bayerMatrix8x8[64] = float[64](
-  0.0/64.0, 48.0/64.0, 12.0/64.0, 60.0/64.0,  3.0/64.0, 51.0/64.0, 15.0/64.0, 63.0/64.0,
-  32.0/64.0,16.0/64.0, 44.0/64.0, 28.0/64.0, 35.0/64.0,19.0/64.0, 47.0/64.0, 31.0/64.0,
-  8.0/64.0, 56.0/64.0,  4.0/64.0, 52.0/64.0, 11.0/64.0,59.0/64.0,  7.0/64.0, 55.0/64.0,
-  40.0/64.0,24.0/64.0, 36.0/64.0, 20.0/64.0, 43.0/64.0,27.0/64.0, 39.0/64.0, 23.0/64.0,
-  2.0/64.0, 50.0/64.0, 14.0/64.0, 62.0/64.0,  1.0/64.0,49.0/64.0, 13.0/64.0, 61.0/64.0,
-  34.0/64.0,18.0/64.0, 46.0/64.0, 30.0/64.0, 33.0/64.0,17.0/64.0, 45.0/64.0, 29.0/64.0,
-  10.0/64.0,58.0/64.0,  6.0/64.0, 54.0/64.0,  9.0/64.0,57.0/64.0,  5.0/64.0, 53.0/64.0,
-  42.0/64.0,26.0/64.0, 38.0/64.0, 22.0/64.0, 41.0/64.0,25.0/64.0, 37.0/64.0, 21.0/64.0
-);
-
-vec3 dither(vec2 uv, vec3 color) {
-  vec2 scaledCoord = floor(uv * resolution / pixelSize);
-  int x = int(mod(scaledCoord.x, 8.0));
-  int y = int(mod(scaledCoord.y, 8.0));
-  float threshold = bayerMatrix8x8[y * 8 + x] - 0.25;
-  float step = 1.0 / (colorNum - 1.0);
-  color += threshold * step;
-  float bias = 0.2;
-  color = clamp(color - bias, 0.0, 1.0);
-  return floor(color * (colorNum - 1.0) + 0.5) / (colorNum - 1.0);
-}
-
-void mainImage(in vec4 inputColor, in vec2 uv, out vec4 outputColor) {
-  vec2 normalizedPixelSize = pixelSize / resolution;
-  vec2 uvPixel = normalizedPixelSize * floor(uv / normalizedPixelSize);
-  vec4 color = texture2D(inputBuffer, uvPixel);
-  color.rgb = dither(uv, color.rgb);
-  outputColor = color;
-}
-`;
-
-class RetroEffectImpl extends Effect {
-  public uniforms: Map<string, THREE.Uniform<any>>;
-  constructor() {
-    const uniforms = new Map<string, THREE.Uniform<any>>([
-      ['colorNum', new THREE.Uniform(4.0)],
-      ['pixelSize', new THREE.Uniform(2.0)]
-    ]);
-    super('RetroEffect', ditherFragmentShader, { uniforms });
-    this.uniforms = uniforms;
-  }
-  set colorNum(value: number) {
-    this.uniforms.get('colorNum')!.value = value;
-  }
-  get colorNum(): number {
-    return this.uniforms.get('colorNum')!.value;
-  }
-  set pixelSize(value: number) {
-    this.uniforms.get('pixelSize')!.value = value;
-  }
-  get pixelSize(): number {
-    return this.uniforms.get('pixelSize')!.value;
-  }
-}
-
-const WrappedRetroEffect = wrapEffect(RetroEffectImpl);
-
-const RetroEffect = forwardRef<RetroEffectImpl, { colorNum: number; pixelSize: number }>((props, ref) => {
-  const { colorNum, pixelSize } = props;
-  return <WrappedRetroEffect ref={ref} colorNum={colorNum} pixelSize={pixelSize} />;
-});
-
-RetroEffect.displayName = 'RetroEffect';
-
-interface WaveUniforms {
-  [key: string]: THREE.Uniform<any>;
-  time: THREE.Uniform<number>;
-  resolution: THREE.Uniform<THREE.Vector2>;
-  waveSpeed: THREE.Uniform<number>;
-  waveFrequency: THREE.Uniform<number>;
-  waveAmplitude: THREE.Uniform<number>;
-  waveColor: THREE.Uniform<THREE.Color>;
-  mousePos: THREE.Uniform<THREE.Vector2>;
-  enableMouseInteraction: THREE.Uniform<number>;
-  mouseRadius: THREE.Uniform<number>;
-}
-
-interface DitheredWavesProps {
-  waveSpeed: number;
-  waveFrequency: number;
-  waveAmplitude: number;
-  waveColor: [number, number, number];
-  colorNum: number;
-  pixelSize: number;
-  disableAnimation: boolean;
-  enableMouseInteraction: boolean;
-  mouseRadius: number;
-}
-
-function DitheredWaves({
-  waveSpeed,
-  waveFrequency,
-  waveAmplitude,
-  waveColor,
-  colorNum,
-  pixelSize,
-  disableAnimation,
-  enableMouseInteraction,
-  mouseRadius
-}: DitheredWavesProps) {
-  const mesh = useRef<THREE.Mesh>(null);
-  const mouseRef = useRef(new THREE.Vector2());
-  const { viewport, size, gl } = useThree();
-
-  const waveUniformsRef = useRef<WaveUniforms>({
-    time: new THREE.Uniform(0),
-    resolution: new THREE.Uniform(new THREE.Vector2(0, 0)),
-    waveSpeed: new THREE.Uniform(waveSpeed),
-    waveFrequency: new THREE.Uniform(waveFrequency),
-    waveAmplitude: new THREE.Uniform(waveAmplitude),
-    waveColor: new THREE.Uniform(new THREE.Color(...waveColor)),
-    mousePos: new THREE.Uniform(new THREE.Vector2(0, 0)),
-    enableMouseInteraction: new THREE.Uniform(enableMouseInteraction ? 1 : 0),
-    mouseRadius: new THREE.Uniform(mouseRadius)
-  });
-
-  useEffect(() => {
-    const dpr = gl.getPixelRatio();
-    const newWidth = Math.floor(size.width * dpr);
-    const newHeight = Math.floor(size.height * dpr);
-    const currentRes = waveUniformsRef.current.resolution.value;
-    if (currentRes.x !== newWidth || currentRes.y !== newHeight) {
-      currentRes.set(newWidth, newHeight);
-    }
-  }, [size, gl]);
-
-  const prevColor = useRef([...waveColor]);
-  useFrame(({ clock }) => {
-    const u = waveUniformsRef.current;
-
-    if (!disableAnimation) {
-      u.time.value = clock.getElapsedTime();
-    }
-
-    if (u.waveSpeed.value !== waveSpeed) u.waveSpeed.value = waveSpeed;
-    if (u.waveFrequency.value !== waveFrequency) u.waveFrequency.value = waveFrequency;
-    if (u.waveAmplitude.value !== waveAmplitude) u.waveAmplitude.value = waveAmplitude;
-
-    if (!prevColor.current.every((v, i) => v === waveColor[i])) {
-      u.waveColor.value.set(...waveColor);
-      prevColor.current = [...waveColor];
-    }
-
-    u.enableMouseInteraction.value = enableMouseInteraction ? 1 : 0;
-    u.mouseRadius.value = mouseRadius;
-
-    if (enableMouseInteraction) {
-      u.mousePos.value.copy(mouseRef.current);
-    }
-  });
-
-  const handlePointerMove = (e: ThreeEvent<PointerEvent>) => {
-    if (!enableMouseInteraction) return;
-    const rect = gl.domElement.getBoundingClientRect();
-    const dpr = gl.getPixelRatio();
-    mouseRef.current.set((e.clientX - rect.left) * dpr, (e.clientY - rect.top) * dpr);
-  };
-
-  return (
-    <>
-      <mesh ref={mesh} scale={[viewport.width, viewport.height, 1]}>
-        <planeGeometry args={[1, 1]} />
-        <shaderMaterial
-          vertexShader={waveVertexShader}
-          fragmentShader={waveFragmentShader}
-          // eslint-disable-next-line react-hooks/refs -- ref is initialized inline, always available
-          uniforms={waveUniformsRef.current}
-        />
-      </mesh>
-
-      <EffectComposer>
-        <RetroEffect colorNum={colorNum} pixelSize={pixelSize} />
-      </EffectComposer>
-
-      <mesh
-        onPointerMove={handlePointerMove}
-        position={[0, 0, 0.01]}
-        scale={[viewport.width, viewport.height, 1]}
-        visible={false}
-      >
-        <planeGeometry args={[1, 1]} />
-        <meshBasicMaterial transparent opacity={0} />
-      </mesh>
-    </>
-  );
-}
-
-interface DitherProps {
-  waveSpeed?: number;
-  waveFrequency?: number;
-  waveAmplitude?: number;
-  waveColor?: [number, number, number];
-  colorNum?: number;
-  pixelSize?: number;
-  disableAnimation?: boolean;
-  enableMouseInteraction?: boolean;
-  mouseRadius?: number;
-}
-
-export default function Dither({
-  waveSpeed = 0.05,
-  waveFrequency = 3,
-  waveAmplitude = 0.3,
-  waveColor = [0.5, 0.5, 0.5],
-  colorNum = 4,
-  pixelSize = 2,
-  disableAnimation = false,
-  enableMouseInteraction = true,
-  mouseRadius = 1
-}: DitherProps) {
-  return (
-    <Canvas
-      className="w-full h-full relative"
-      camera={{ position: [0, 0, 6] }}
-      dpr={1}
-      gl={{ antialias: true, preserveDrawingBuffer: true }}
-    >
-      <DitheredWaves
-        waveSpeed={waveSpeed}
-        waveFrequency={waveFrequency}
-        waveAmplitude={waveAmplitude}
-        waveColor={waveColor}
-        colorNum={colorNum}
-        pixelSize={pixelSize}
-        disableAnimation={disableAnimation}
-        enableMouseInteraction={enableMouseInteraction}
-        mouseRadius={mouseRadius}
-      />
-    </Canvas>
-  );
-}
diff --git a/src/components/PaymentInterface.tsx b/src/components/PaymentInterface.tsx
index 84f6e7d..8763e4a 100644
--- a/src/components/PaymentInterface.tsx
+++ b/src/components/PaymentInterface.tsx
@@ -14,6 +14,7 @@ import { QuoteResponse } from '@/types/provider'
 import { useTransactionExecutor } from '@/hooks/useTransactionExecutor'
 import { useToast } from '@/components/ui/use-toast'
 import type { UnifiedChain, UnifiedToken } from '@/lib/chain-registry'
+import { collapseTokensBySymbol } from '@/lib/token-filter'
 
 // Chain type group labels for the dropdown
 const CHAIN_TYPE_LABELS: Record<string, string> = {
@@ -57,9 +58,15 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
   const { chain: connectedChain } = useAccount()
   const { switchChain } = useSwitchChain()
   const { toast } = useToast()
-  
+
   // Custom Executor Hook
-  const { execute, status: executorStatus, step: executorStep, error: executorError, txHash } = useTransactionExecutor()
+  const {
+    execute,
+    status: executorStatus,
+    step: executorStep,
+    error: executorError,
+    txHash,
+  } = useTransactionExecutor()
 
   // Dynamic chain/token state
   const [dynamicChains, setDynamicChains] = useState<UnifiedChain[]>([])
@@ -68,12 +75,16 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
   const [tokensLoading, setTokensLoading] = useState(false)
 
   const [fromChainKey, setFromChainKey] = useState<string>(
-    connectedChain?.id ? String(connectedChain.id) : '42161'
+    connectedChain?.id ? String(connectedChain.id) : '42161',
+  )
+  const [fromTokenAddress, setFromTokenAddress] = useState(
+    '0x0000000000000000000000000000000000000000',
   )
-  const [fromTokenAddress, setFromTokenAddress] = useState('0x0000000000000000000000000000000000000000')
 
   // Derive chain type from dynamic chains
-  const selectedChain = dynamicChains.find(c => String(c.chainId) === fromChainKey || c.key === fromChainKey)
+  const selectedChain = dynamicChains.find(
+    (c) => String(c.chainId) === fromChainKey || c.key === fromChainKey,
+  )
   const chainType = selectedChain?.type || 'evm'
 
   // Derive numeric chainId for wagmi compatibility
@@ -82,7 +93,12 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
     return !isNaN(num) && Number.isInteger(num) ? num : 0
   })()
 
-  const toChainKey = link.receive_mode === 'same_chain' ? fromChainKey : (link.receive_chain_id ? String(link.receive_chain_id) : '42161')
+  const toChainKey =
+    link.receive_mode === 'same_chain'
+      ? fromChainKey
+      : link.receive_chain_id
+        ? String(link.receive_chain_id)
+        : '42161'
 
   const [quotes, setQuotes] = useState<QuoteResponse[]>([])
   const [selectedQuote, setSelectedQuote] = useState<QuoteResponse | null>(null)
@@ -103,10 +119,20 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
   const isFixedAmount = typeof link.amount === 'number' && link.amount > 0
   const displayAmountUSD = isFixedAmount ? link.amount! : parseFloat(manualAmount) || 0
 
-  const fromToken = dynamicTokens.find(t => t.address.toLowerCase() === fromTokenAddress.toLowerCase())
+  const fromToken = dynamicTokens.find(
+    (t) => t.address.toLowerCase() === fromTokenAddress.toLowerCase(),
+  )
+
+  // Defensive client-side collapse: one canonical row per symbol so the dropdown
+  // never shows duplicate USDC/SOL even if an unmerged cache row slips through.
+  // Selection still resolves against the full dynamicTokens list above.
+  const displayTokens = collapseTokensBySymbol(dynamicTokens, fromChainKey)
 
   // Dynamic USDC address resolution for destination chain
   const [resolvedUSDCAddress, setResolvedUSDCAddress] = useState<string | undefined>(undefined)
+  // Destination-token decimals — sent to the quote API so ranking normalizes each
+  // provider's output against the real dest decimals (USDC = 6).
+  const [resolvedUSDCDecimals, setResolvedUSDCDecimals] = useState<number | undefined>(undefined)
 
   useEffect(() => {
     if (link.receive_token || link.stealth_chain_native) return
@@ -116,11 +142,10 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
         const res = await fetch(`/api/tokens?chainKey=${toChainKey}`)
         const data = await res.json()
         if (data.success && data.tokens) {
-          const usdc = data.tokens.find((t: any) =>
-            t.symbol?.toUpperCase() === 'USDC'
-          )
+          const usdc = data.tokens.find((t: any) => t.symbol?.toUpperCase() === 'USDC')
           if (usdc?.address) {
             setResolvedUSDCAddress(usdc.address)
+            if (typeof usdc.decimals === 'number') setResolvedUSDCDecimals(usdc.decimals)
             return
           }
         }
@@ -136,7 +161,7 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
   // If stealth mode, destination is always native token on the receive chain
   const destinationToken = link.stealth_chain_native
     ? '0x0000000000000000000000000000000000000000'
-    : (link.receive_token || resolvedUSDCAddress || getUSDCAddress(toChainKey))
+    : link.receive_token || resolvedUSDCAddress || getUSDCAddress(toChainKey)
 
   // Fetch chains on mount
   useEffect(() => {
@@ -185,11 +210,14 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
   const { data: balanceData } = useBalance({
     address: address,
     chainId: fromChainId,
-    token: fromTokenAddress === '0x0000000000000000000000000000000000000000' ? undefined : fromTokenAddress as `0x${string}`,
+    token:
+      fromTokenAddress === '0x0000000000000000000000000000000000000000'
+        ? undefined
+        : (fromTokenAddress as `0x${string}`),
     query: {
       enabled: !!address && !!fromChainId && chainType === 'evm',
-      refetchInterval: 10000
-    }
+      refetchInterval: 10000,
+    },
   })
 
   const refreshIntervalRef = useRef<NodeJS.Timeout | null>(null)
@@ -222,7 +250,7 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
       // Calculate converted amount if we have a USD amount
       if (displayAmountUSD > 0 && data.priceUSD > 0) {
         const toSymbol = link.receive_token_symbol || 'USDC'
-        const slippage = (STABLECOINS.has(fromToken.symbol) && STABLECOINS.has(toSymbol)) ? 0.5 : 1.0
+        const slippage = STABLECOINS.has(fromToken.symbol) && STABLECOINS.has(toSymbol) ? 0.5 : 1.0
         const rawAmount = displayAmountUSD / data.priceUSD
         const withSlippage = rawAmount * (1 + slippage / 100)
 
@@ -294,7 +322,9 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
     const isEvmChain = chainType === 'evm'
     const isEvmAddress = address?.startsWith('0x')
     if (isEvmChain && !isEvmAddress) {
-      setError('Your connected wallet is not an EVM wallet. Please switch to an EVM wallet (MetaMask, etc.) using the wallet button to pay on this chain.')
+      setError(
+        'Your connected wallet is not an EVM wallet. Please switch to an EVM wallet (MetaMask, etc.) using the wallet button to pay on this chain.',
+      )
       setIsLoading(false)
       return
     }
@@ -314,6 +344,7 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
           fromAddress: address,
           toAddress: link.recipient_address,
           fromTokenDecimals: fromToken.decimals,
+          toTokenDecimals: resolvedUSDCDecimals,
         }),
       })
 
@@ -322,8 +353,14 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
         setQuotes(data.routes)
         const best = data.bestQuote || data.routes[0]
         setSelectedQuote(best)
+      } else if (data.unsupported && data.reason) {
+        throw new Error(data.reason)
       } else {
-        throw new Error(data.error || 'No routes found for this swap. Try a different token or chain.')
+        throw new Error(
+          data.reason ||
+            data.error ||
+            'No routes found for this swap. Try a different token or chain.',
+        )
       }
     } catch (e) {
       console.error(e)
@@ -336,15 +373,14 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
 
   useEffect(() => {
     if (selectedQuote?.metadata?.insufficientBalance) {
-        toast({
-            variant: "destructive",
-            title: "Insufficient Balance",
-            description: `You don't have enough balance for the ${selectedQuote.provider} route. Try a different token or add funds.`
-        })
+      toast({
+        variant: 'destructive',
+        title: 'Insufficient Balance',
+        description: `You don't have enough balance for the ${selectedQuote.provider} route. Try a different token or add funds.`,
+      })
     }
   }, [selectedQuote])
 
-
   const handleExecute = async () => {
     if (!selectedQuote || !address) return
     setIsLoading(true)
@@ -377,7 +413,7 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
 
       // 2. Execute via Executor Hook (Handles LiFi/Rango logic)
       const hash = await execute(selectedQuote, link.recipient_address)
-      
+
       if (!hash) throw new Error('Execution completed but no hash returned')
 
       // 3. Update Backend with Hash
@@ -385,7 +421,7 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
         await fetch(`/api/transactions/${transactionId}/hash`, {
           method: 'PATCH',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ txHash: hash })
+          body: JSON.stringify({ txHash: hash }),
         })
       } catch (err) {
         console.error('Failed to update backend with hash:', err)
@@ -394,7 +430,6 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
       if (onSuccess) {
         onSuccess(hash, transactionId)
       }
-
     } catch (e) {
       console.error(e)
       const message = e instanceof Error ? e.message : 'Transaction Failed'
@@ -410,12 +445,17 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
       setError(executorError)
       setIsLoading(false)
     }
-    // We don't auto-handle success status here because handleExecute awaits execute() 
+    // We don't auto-handle success status here because handleExecute awaits execute()
     // and calls onSuccess manually.
   }, [executorError])
 
-  const timeSinceUpdate = lastPriceUpdate > 0 ? Math.floor((Date.now() - lastPriceUpdate) / 1000) : null
-  const isExecuting = isLoading || executorStatus === 'approving' || executorStatus === 'executing'
+  const timeSinceUpdate =
+    lastPriceUpdate > 0 ? Math.floor((Date.now() - lastPriceUpdate) / 1000) : null
+  const isExecuting =
+    isLoading ||
+    executorStatus === 'approving' ||
+    executorStatus === 'executing' ||
+    executorStatus === 'submitted'
 
   return (
     <div className="w-full max-w-2xl mx-auto">
@@ -467,7 +507,8 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
                         ≈ {convertedAmount} {fromToken.symbol}
                       </span>
                       <span className="text-[10px] text-muted-foreground font-mono">
-                        (${tokenPriceUSD?.toLocaleString(undefined, { maximumFractionDigits: 2 })} / {fromToken.symbol})
+                        (${tokenPriceUSD?.toLocaleString(undefined, { maximumFractionDigits: 2 })} /{' '}
+                        {fromToken.symbol})
                       </span>
                       <button
                         onClick={fetchPrice}
@@ -517,17 +558,24 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
 
           <div className="space-y-4">
             <p className="text-[11px] text-yellow-500 text-center md:text-left font-mono">
-               We recommend Arbitrum for lowest fees, near-instant settlement, and greater route compatibility.
+              We recommend Arbitrum for lowest fees, near-instant settlement, and greater route
+              compatibility.
             </p>
-          </div>  
-            {/* Controls Grid */}
-            <div className="grid grid-cols-1 md:grid-cols-2 gap-6 bg-muted/30 p-6 border border-border">
-              {/* Network Selection */}
+          </div>
+          {/* Controls Grid */}
+          <div className="grid grid-cols-1 md:grid-cols-2 gap-6 bg-muted/30 p-6 border border-border">
+            {/* Network Selection */}
             <div className="space-y-3">
-              <Label className="text-xs font-mono uppercase tracking-widest text-muted-foreground">Payment Network</Label>
+              <Label className="text-xs font-mono uppercase tracking-widest text-muted-foreground">
+                Payment Network
+              </Label>
               <div className="relative">
                 {selectedChain?.logoUrl ? (
-                  <img src={selectedChain.logoUrl} alt={selectedChain.name} className="absolute left-3 top-1/2 -translate-y-1/2 w-5 h-5 rounded-full object-cover" />
+                  <img
+                    src={selectedChain.logoUrl}
+                    alt={selectedChain.name}
+                    className="absolute left-3 top-1/2 -translate-y-1/2 w-5 h-5 rounded-full object-cover"
+                  />
                 ) : (
                   <div className="absolute left-3 top-1/2 -translate-y-1/2 w-2 h-2 bg-green-500" />
                 )}
@@ -546,32 +594,46 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
                     {(() => {
                       const popularIds = ['42161', '8453', '137', '10', '1', 'solana']
                       const popularChains = popularIds
-                        .map(id => dynamicChains.find(c => c.key === id || String(c.chainId) === id))
+                        .map((id) =>
+                          dynamicChains.find((c) => c.key === id || String(c.chainId) === id),
+                        )
                         .filter(Boolean) as UnifiedChain[]
-                      const remainingChains = dynamicChains.filter(c =>
-                        !popularIds.includes(c.key) && !popularIds.includes(String(c.chainId || ''))
+                      const remainingChains = dynamicChains.filter(
+                        (c) =>
+                          !popularIds.includes(c.key) &&
+                          !popularIds.includes(String(c.chainId || '')),
                       )
 
                       return (
                         <>
                           {popularChains.length > 0 && (
                             <optgroup label="⭐ Popular">
-                              {popularChains.map(c => (
-                                <option key={c.key} value={c.key}>{c.name}</option>
+                              {popularChains.map((c) => (
+                                <option key={c.key} value={c.key}>
+                                  {c.name}
+                                </option>
                               ))}
                             </optgroup>
                           )}
                           {Object.entries(
-                            remainingChains.reduce((groups, chain) => {
-                              const type = chain.type || 'evm'
-                              if (!groups[type]) groups[type] = []
-                              groups[type].push(chain)
-                              return groups
-                            }, {} as Record<string, UnifiedChain[]>)
+                            remainingChains.reduce(
+                              (groups, chain) => {
+                                const type = chain.type || 'evm'
+                                if (!groups[type]) groups[type] = []
+                                groups[type].push(chain)
+                                return groups
+                              },
+                              {} as Record<string, UnifiedChain[]>,
+                            ),
                           ).map(([type, chains]) => (
-                            <optgroup key={type} label={CHAIN_TYPE_LABELS[type] || type.toUpperCase()}>
-                              {chains.map(c => (
-                                <option key={c.key} value={c.key}>{c.name}</option>
+                            <optgroup
+                              key={type}
+                              label={CHAIN_TYPE_LABELS[type] || type.toUpperCase()}
+                            >
+                              {chains.map((c) => (
+                                <option key={c.key} value={c.key}>
+                                  {c.name}
+                                </option>
                               ))}
                             </optgroup>
                           ))}
@@ -581,8 +643,21 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
                   </select>
                 )}
                 <div className="absolute right-4 top-1/2 -translate-y-1/2 pointer-events-none text-muted-foreground">
-                  <svg width="10" height="6" viewBox="0 0 10 6" fill="none" xmlns="http://www.w3.org/2000/svg" className="opacity-50">
-                    <path d="M1 1L5 5L9 1" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round"/>
+                  <svg
+                    width="10"
+                    height="6"
+                    viewBox="0 0 10 6"
+                    fill="none"
+                    xmlns="http://www.w3.org/2000/svg"
+                    className="opacity-50"
+                  >
+                    <path
+                      d="M1 1L5 5L9 1"
+                      stroke="currentColor"
+                      strokeWidth="1.5"
+                      strokeLinecap="round"
+                      strokeLinejoin="round"
+                    />
                   </svg>
                 </div>
               </div>
@@ -590,7 +665,9 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
 
             {/* Asset Selection */}
             <div className="space-y-3">
-              <Label className="text-xs font-mono uppercase tracking-widest text-muted-foreground">Payment Asset</Label>
+              <Label className="text-xs font-mono uppercase tracking-widest text-muted-foreground">
+                Payment Asset
+              </Label>
               <div className="relative">
                 {tokensLoading ? (
                   <div className="w-full px-4 py-4 bg-background border border-border text-muted-foreground font-mono text-sm flex items-center gap-2">
@@ -603,16 +680,30 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
                     value={fromTokenAddress}
                     onChange={(e) => handleTokenChange(e.target.value)}
                   >
-                    {dynamicTokens.map(t => (
+                    {displayTokens.map((t) => (
                       <option key={t.address} value={t.address}>
-                        {t.symbol}{t.name && t.name !== t.symbol ? ` — ${t.name}` : ''}
+                        {t.symbol}
+                        {t.name && t.name !== t.symbol ? ` — ${t.name}` : ''}
                       </option>
                     ))}
                   </select>
                 )}
                 <div className="absolute right-4 top-1/2 -translate-y-1/2 pointer-events-none text-muted-foreground">
-                  <svg width="10" height="6" viewBox="0 0 10 6" fill="none" xmlns="http://www.w3.org/2000/svg" className="opacity-50">
-                    <path d="M1 1L5 5L9 1" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round"/>
+                  <svg
+                    width="10"
+                    height="6"
+                    viewBox="0 0 10 6"
+                    fill="none"
+                    xmlns="http://www.w3.org/2000/svg"
+                    className="opacity-50"
+                  >
+                    <path
+                      d="M1 1L5 5L9 1"
+                      stroke="currentColor"
+                      strokeWidth="1.5"
+                      strokeLinecap="round"
+                      strokeLinejoin="round"
+                    />
                   </svg>
                 </div>
               </div>
@@ -623,7 +714,9 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
           <Button
             className="w-full h-16 text-base font-bold tracking-wide bg-foreground text-background hover:bg-foreground/90 transition-all disabled:opacity-50 disabled:cursor-not-allowed font-mono"
             onClick={handleGetQuote}
-            disabled={isExecuting || (isFixedAmount ? !convertedAmount : !manualAmount) || priceLoading}
+            disabled={
+              isExecuting || (isFixedAmount ? !convertedAmount : !manualAmount) || priceLoading
+            }
           >
             {isExecuting ? (
               <div className="flex items-center gap-2">
@@ -646,7 +739,9 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
             <div className="animate-in fade-in slide-in-from-bottom-4 duration-500 pt-4">
               <div className="flex items-center gap-4 mb-6">
                 <div className="h-px flex-1 bg-border" />
-                <span className="text-xs text-muted-foreground font-mono uppercase tracking-widest">ROUTE_OPTIMIZED</span>
+                <span className="text-xs text-muted-foreground font-mono uppercase tracking-widest">
+                  ROUTE_OPTIMIZED
+                </span>
                 <div className="h-px flex-1 bg-border" />
               </div>
 
@@ -655,16 +750,22 @@ export default function PaymentInterface({ link, onSuccess }: PaymentInterfacePr
                 onSwap={handleExecute}
                 isLoading={isExecuting}
                 loadingStep={executorStep || undefined}
-                fromTokenInfo={fromToken ? { symbol: fromToken.symbol, decimals: fromToken.decimals } : undefined}
-                toTokenInfo={link.stealth_chain_native
-                  ? {
-                      symbol: link.receive_token_symbol || 'ETH',
-                      decimals: 18,
-                    }
-                  : {
-                      symbol: link.receive_token_symbol || 'USDC',
-                      decimals: (link.receive_token_symbol === 'DAI' || link.receive_token_symbol === 'ETH') ? 18 : 6,
-                    }
+                fromTokenInfo={
+                  fromToken ? { symbol: fromToken.symbol, decimals: fromToken.decimals } : undefined
+                }
+                toTokenInfo={
+                  link.stealth_chain_native
+                    ? {
+                        symbol: link.receive_token_symbol || 'ETH',
+                        decimals: 18,
+                      }
+                    : {
+                        symbol: link.receive_token_symbol || 'USDC',
+                        decimals:
+                          link.receive_token_symbol === 'DAI' || link.receive_token_symbol === 'ETH'
+                            ? 18
+                            : 6,
+                      }
                 }
               />
             </div>
diff --git a/src/hooks/useTransactionExecutor.ts b/src/hooks/useTransactionExecutor.ts
index 473b631..ed27574 100644
--- a/src/hooks/useTransactionExecutor.ts
+++ b/src/hooks/useTransactionExecutor.ts
@@ -16,12 +16,14 @@ import {
   getSolanaConnection,
   isSolNative,
 } from '@/lib/solana'
-import { PublicKey } from '@solana/web3.js'
+import { resolveExecutionPath, isCrossChainSwap } from '@/lib/execution-path'
+import { PublicKey, VersionedTransaction, Transaction } from '@solana/web3.js'
 
 OpenAPI.BASE = 'https://1click.chaindefuser.com'
 
 // Initialize Rango Client
-const RANGO_API_KEY = process.env.NEXT_PUBLIC_RANGO_API_KEY || 'c6381a79-2817-4602-83bf-6a641a409e32' 
+const RANGO_API_KEY =
+  process.env.NEXT_PUBLIC_RANGO_API_KEY || 'c6381a79-2817-4602-83bf-6a641a409e32'
 const rangoClient = new RangoClient(RANGO_API_KEY)
 
 const erc20Abi = parseAbi([
@@ -34,7 +36,7 @@ const erc20Abi = parseAbi([
 enum TransactionStatus {
   FAILED = 'FAILED',
   SUCCESS = 'SUCCESS',
-  RUNNING = 'RUNNING'
+  RUNNING = 'RUNNING',
 }
 
 enum TransactionType {
@@ -44,10 +46,19 @@ enum TransactionType {
   SOLANA = 'SOLANA',
   TRON = 'TRON',
   STARKNET = 'STARKNET',
-  TON = 'TON'
+  TON = 'TON',
 }
 
-export type ExecutorStatus = 'idle' | 'approving' | 'executing' | 'completed' | 'failed'
+// 'submitted' = source tx broadcast for a cross-chain atomic swap; settlement on
+// the destination is still pending and tracked by the server-side poller. We do
+// NOT claim 'completed' on broadcast for cross-chain bridges (they take minutes).
+export type ExecutorStatus =
+  | 'idle'
+  | 'approving'
+  | 'executing'
+  | 'submitted'
+  | 'completed'
+  | 'failed'
 
 export function useTransactionExecutor() {
   const { data: walletClient } = useWalletClient()
@@ -55,7 +66,7 @@ export function useTransactionExecutor() {
   const { switchChainAsync } = useSwitchChain()
   const config = useConfig()
   const { address } = useAppKitAccount()
-  
+
   const [status, setStatus] = useState<ExecutorStatus>('idle')
   const [error, setError] = useState<string | null>(null)
   const [txHash, setTxHash] = useState<string | null>(null)
@@ -77,7 +88,7 @@ export function useTransactionExecutor() {
               await switchChainAsync({ chainId })
               const client = await getWalletClient(config, { chainId })
               return client
-            }
+            },
           }),
           // Solana provider for LIFI
           Solana({
@@ -85,257 +96,281 @@ export function useTransactionExecutor() {
               const solana = (window as any).phantom?.solana || (window as any).solana
               if (!solana) throw new Error('Solana wallet not connected')
               return solana
-            }
-          })
-        ]
+            },
+          }),
+        ],
       })
     }
   }, [walletClient, switchChainAsync])
 
-  const executeLifi = useCallback(async (route: Route) => {
-    if (!walletClient) throw new Error('Wallet not connected')
-    
-    setStatus('executing')
-    setStep('Executing LI.FI Route...')
-    
-    try {
-      // Execute route (signer is handled by global config)
-      const executedRoute = await executeRoute(route)
-
-      // The SDK returns the completed route. We extract the final TX hash from the last step.
-      const lastStep = executedRoute.steps[executedRoute.steps.length - 1]
-      const finalTx = lastStep.execution?.process.find(p => p.type === 'CROSS_CHAIN' || p.type === 'SWAP')?.txHash
-      
-      if (finalTx) {
-        setTxHash(finalTx)
-        setStatus('completed')
-        return finalTx
-      } else {
-         // Fallback if SDK doesn't return explicit hash in expected place
-         setStatus('completed')
-         return '0x' 
+  const executeLifi = useCallback(
+    async (route: Route) => {
+      if (!walletClient) throw new Error('Wallet not connected')
+
+      setStatus('executing')
+      setStep('Executing LI.FI Route...')
+
+      try {
+        // Execute route (signer is handled by global config)
+        const executedRoute = await executeRoute(route)
+
+        // The SDK returns the completed route. We extract the final TX hash from the last step.
+        const lastStep = executedRoute.steps[executedRoute.steps.length - 1]
+        const finalTx = lastStep.execution?.process.find(
+          (p) => p.type === 'CROSS_CHAIN' || p.type === 'SWAP',
+        )?.txHash
+
+        if (finalTx) {
+          setTxHash(finalTx)
+          setStatus('completed')
+          return finalTx
+        } else {
+          // Fallback if SDK doesn't return explicit hash in expected place
+          setStatus('completed')
+          return '0x'
+        }
+      } catch (e: any) {
+        console.error('LI.FI Execution Error:', e)
+        setError(e.message || 'LI.FI Execution Failed')
+        setStatus('failed')
+        throw e
       }
-    } catch (e: any) {
-      console.error('LI.FI Execution Error:', e)
-      setError(e.message || 'LI.FI Execution Failed')
-      setStatus('failed')
-      throw e
-    }
-  }, [walletClient])
+    },
+    [walletClient],
+  )
 
-  const executeNearIntents = useCallback(async (quote: QuoteResponse) => {
-    if (!walletClient) throw new Error('Wallet not connected')
-    
-    setStatus('executing')
-    setStep('Executing Near Intents Deposit...')
+  const executeNearIntents = useCallback(
+    async (quote: QuoteResponse) => {
+      if (!walletClient) throw new Error('Wallet not connected')
 
-    try {
-      // 1. Extract Deposit Address
-      const depositAddress = quote.transactionRequest?.depositAddress || quote.metadata?.depositAddress
-      if (!depositAddress) throw new Error('Deposit address missing for Near Intents')
+      setStatus('executing')
+      setStep('Executing Near Intents Deposit...')
+
+      try {
+        // 1. Extract Deposit Address
+        const depositAddress =
+          quote.transactionRequest?.depositAddress || quote.metadata?.depositAddress
+        if (!depositAddress) throw new Error('Deposit address missing for Near Intents')
 
-      const amount = BigInt(quote.fromAmount)
-      const fromToken = quote.routes[0]?.action.fromToken
+        const amount = BigInt(quote.fromAmount)
+        const fromToken = quote.routes[0]?.action.fromToken
 
-      let hash: `0x${string}`
+        let hash: `0x${string}`
 
-      // 2. Send Transaction (Native vs ERC20)
-      if (fromToken.address === '0x0000000000000000000000000000000000000000') {
-         // Native Transfer
-         hash = await walletClient.sendTransaction({
+        // 2. Send Transaction (Native vs ERC20)
+        if (fromToken.address === '0x0000000000000000000000000000000000000000') {
+          // Native Transfer
+          hash = await walletClient.sendTransaction({
             to: depositAddress as `0x${string}`,
-            value: amount
-         })
-      } else {
-         // ERC20 Transfer
-         hash = await walletClient.writeContract({
+            value: amount,
+          })
+        } else {
+          // ERC20 Transfer
+          hash = await walletClient.writeContract({
             address: fromToken.address as `0x${string}`,
             abi: erc20Abi,
             functionName: 'transfer',
-            args: [depositAddress as `0x${string}`, amount]
-         })
-      }
+            args: [depositAddress as `0x${string}`, amount],
+          })
+        }
 
-      setTxHash(hash)
-      setStep('Submitting Transaction Hash...')
+        setTxHash(hash)
+        setStep('Submitting Transaction Hash...')
 
-      // 3. Submit Hash to Solver Network
-      try {
-        await OneClickService.submitDepositTx({
+        // 3. Submit Hash to Solver Network (include memo for memo-required chains)
+        try {
+          await OneClickService.submitDepositTx({
             txHash: hash,
-            depositAddress
-        })
-      } catch (e) {
-        console.warn('Failed to submit tx hash to Near Intents:', e)
-        // Non-blocking error, solver will find it eventually
+            depositAddress,
+            memo: quote.metadata?.depositMemo as string | undefined,
+          })
+        } catch (e) {
+          console.warn('Failed to submit tx hash to Near Intents:', e)
+          // Non-blocking error, solver will find it eventually
+        }
+
+        setStatus('completed')
+        return hash
+      } catch (e: any) {
+        console.error('Near Intents Execution Error:', e)
+        setError(e.message || 'Near Intents Execution Failed')
+        setStatus('failed')
+        throw e
       }
+    },
+    [walletClient],
+  )
 
-      setStatus('completed')
-      return hash
+  const executeRango = useCallback(
+    async (quote: QuoteResponse, recipientAddress?: string) => {
+      if (!walletClient || !publicClient) throw new Error('Wallet not connected')
+      const params = quote.metadata?.rangoParams as any
+      if (!params) throw new Error('Rango params missing from quote metadata')
 
-    } catch (e: any) {
-      console.error('Near Intents Execution Error:', e)
-      setError(e.message || 'Near Intents Execution Failed')
-      setStatus('failed')
-      throw e
-    }
-  }, [walletClient])
+      try {
+        // 1. Prepare Swap Request
+        // Rango expects the full params again for the swap
+        const swapRequest = {
+          ...params,
+          fromAddress: walletClient.account.address,
+          toAddress: recipientAddress || walletClient.account.address,
+          slippage: params.slippage || 1.0,
+          disableEstimate: false,
+        }
 
-  const executeRango = useCallback(async (quote: QuoteResponse, recipientAddress?: string) => {
-    if (!walletClient || !publicClient) throw new Error('Wallet not connected')
-    const params = quote.metadata?.rangoParams as any
-    if (!params) throw new Error('Rango params missing from quote metadata')
+        setStep('Requesting Swap Transaction...')
+        setStatus('approving')
 
-    try {
-      // 1. Prepare Swap Request
-      // Rango expects the full params again for the swap
-      const swapRequest = {
-        ...params,
-        fromAddress: walletClient.account.address,
-        toAddress: recipientAddress || walletClient.account.address,
-        slippage: params.slippage || 1.0,
-        disableEstimate: false
-      }
+        // 2. Call Swap API (Step 1)
+        // We pass the full request to get the tx data
+        const swapResponse = await rangoClient.swap(swapRequest)
 
-      setStep('Requesting Swap Transaction...')
-      setStatus('approving')
-
-      // 2. Call Swap API (Step 1)
-      // We pass the full request to get the tx data
-      const swapResponse = await rangoClient.swap(swapRequest)
-
-      if (swapResponse.error) throw new Error(swapResponse.error)
-      
-      const requestId = swapResponse.requestId
-      const tx = swapResponse.tx
-      
-      if (!tx) throw new Error('Failed to get transaction data from Rango')
-
-      // 3. Handle Approval if present
-      // @ts-ignore - Local enum matching
-      if (tx.type === TransactionType.EVM && tx.approveData && tx.approveTo) {
-        setStep('Approving Token...')
-        const approveHash = await walletClient.sendTransaction({
-          to: tx.approveTo as `0x${string}`,
-          data: tx.approveData as `0x${string}`,
-        })
+        if (swapResponse.error) throw new Error(swapResponse.error)
 
-        setStep('Waiting for Approval...')
-        await publicClient.waitForTransactionReceipt({ hash: approveHash })
-        
-        // Loop check isApproved from Rango
-        let isApproved = false
-        while (!isApproved) {
-            await new Promise(r => setTimeout(r, 3000))
+        const requestId = swapResponse.requestId
+        const tx = swapResponse.tx
+
+        if (!tx) throw new Error('Failed to get transaction data from Rango')
+
+        // 3. Handle Approval if present
+        // @ts-ignore - Local enum matching
+        if (tx.type === TransactionType.EVM && tx.approveData && tx.approveTo) {
+          setStep('Approving Token...')
+          const approveHash = await walletClient.sendTransaction({
+            to: tx.approveTo as `0x${string}`,
+            data: tx.approveData as `0x${string}`,
+          })
+
+          setStep('Waiting for Approval...')
+          await publicClient.waitForTransactionReceipt({ hash: approveHash })
+
+          // Loop check isApproved from Rango
+          let isApproved = false
+          while (!isApproved) {
+            await new Promise((r) => setTimeout(r, 3000))
             const check = await rangoClient.isApproved(requestId, approveHash)
             if (check.isApproved) isApproved = true
+          }
         }
 
-      }
+        // 4. Execute Main Swap
+        setStep('Executing Swap...')
+        setStatus('executing')
 
-      // 4. Execute Main Swap
-      setStep('Executing Swap...')
-      setStatus('executing')
-      
-      // @ts-ignore
-      if (tx.type === TransactionType.SOLANA) {
-        // Solana transaction from Rango
-        return await executeSolanaTx(tx)
-      }
+        // @ts-ignore
+        if (tx.type === TransactionType.SOLANA) {
+          // Solana transaction from Rango
+          return await executeSolanaTx(tx)
+        }
 
-      // @ts-ignore
-      if (tx.type !== TransactionType.EVM) throw new Error(`Unsupported transaction type: ${tx.type}`)
+        // @ts-ignore
+        if (tx.type !== TransactionType.EVM)
+          throw new Error(`Unsupported transaction type: ${tx.type}`)
 
-      const hash = await walletClient.sendTransaction({
-        to: tx.txTo as `0x${string}`,
-        data: tx.txData as `0x${string}`,
-        value: tx.value ? BigInt(tx.value) : BigInt(0),
-      })
+        const hash = await walletClient.sendTransaction({
+          to: tx.txTo as `0x${string}`,
+          data: tx.txData as `0x${string}`,
+          value: tx.value ? BigInt(tx.value) : BigInt(0),
+        })
 
-      setTxHash(hash)
-      setStep('Waiting for Confirmation...')
-      
-      // 5. Poll Status
-      let finished = false
-      while (!finished) {
-          await new Promise(r => setTimeout(r, 5000))
+        setTxHash(hash)
+        setStep('Waiting for Confirmation...')
+
+        // 5. Poll Status
+        let finished = false
+        while (!finished) {
+          await new Promise((r) => setTimeout(r, 5000))
           const statusRes = await rangoClient.status({ requestId, txId: hash })
           // @ts-ignore
-          if (statusRes.status === TransactionStatus.SUCCESS || statusRes.status === TransactionStatus.FAILED) {
-              finished = true
-              // @ts-ignore
-              if (statusRes.status === TransactionStatus.FAILED) {
-                  throw new Error('Rango Transaction Failed on-chain')
-              }
+          if (
+            statusRes.status === TransactionStatus.SUCCESS ||
+            statusRes.status === TransactionStatus.FAILED
+          ) {
+            finished = true
+            // @ts-ignore
+            if (statusRes.status === TransactionStatus.FAILED) {
+              throw new Error('Rango Transaction Failed on-chain')
+            }
           }
+        }
+
+        setStatus('completed')
+        return hash
+      } catch (e: any) {
+        console.error('Rango Execution Error:', e)
+        setError(e.message || 'Rango Execution Failed')
+        setStatus('failed')
+        throw e
       }
+    },
+    [walletClient, publicClient],
+  )
 
-      setStatus('completed')
-      return hash
+  const executeCCTP = useCallback(
+    async (quote: QuoteResponse, recipientAddress?: string) => {
+      if (!walletClient || !evmAdapter) throw new Error('Wallet or Adapter not ready')
 
-    } catch (e: any) {
-      console.error('Rango Execution Error:', e)
-      setError(e.message || 'Rango Execution Failed')
-      setStatus('failed')
-      throw e
-    }
-  }, [walletClient, publicClient])
+      try {
+        const sourceChain = quote.metadata?.sourceChain as string
+        const destChain = quote.metadata?.destChain as string
+
+        const fromDecimals = quote.routes[0]?.action.fromToken.decimals || 6
+        const amountHuman = (Number(quote.fromAmount) / Math.pow(10, fromDecimals)).toString()
+
+        setStatus('approving')
+        setStep('Initializing CCTP Transfer...')
+
+        const result = await executeCCTPBridge(
+          {
+            fromChain: sourceChain,
+            toChain: destChain,
+            amount: amountHuman,
+            recipientAddress: recipientAddress || walletClient.account.address,
+            fromAdapter: evmAdapter,
+            toAdapter: evmAdapter,
+          },
+          {
+            onEvent: (evt: any) => {
+              console.log('CCTP Event:', evt)
+
+              if (evt.type === 'APPROVAL_TX_SENT') setStep('Approving USDC...')
+              if (evt.type === 'BURN_TX_SENT') {
+                setStatus('executing')
+                setStep('Burning USDC...')
+              }
+              if (evt.step === 'burn' && evt.status === 'complete') {
+                setStep('Waiting for Circle Attestation (~20 mins)...')
+              }
+              if (evt.step === 'mint' && evt.status === 'progress') {
+                setStep('Minting on Destination...')
+              }
+            },
+          },
+        )
 
-  const executeCCTP = useCallback(async (quote: QuoteResponse, recipientAddress?: string) => {
-    if (!walletClient || !evmAdapter) throw new Error('Wallet or Adapter not ready')
+        if (!result?.data) throw new Error('CCTP Bridge Failed')
 
-    try {
-      const sourceChain = quote.metadata?.sourceChain as string
-      const destChain = quote.metadata?.destChain as string
-      const amount = (BigInt(quote.fromAmount) / BigInt(1e12)).toString() // Convert Wei (18) 
-      
-      const fromDecimals = quote.routes[0]?.action.fromToken.decimals || 6
-      const amountHuman = (Number(quote.fromAmount) / Math.pow(10, fromDecimals)).toString()
-
-      setStatus('approving')
-      setStep('Initializing CCTP Transfer...')
-
-      const result = await executeCCTPBridge({
-        fromChain: sourceChain,
-        toChain: destChain,
-        amount: amountHuman, 
-        recipientAddress: recipientAddress || walletClient.account.address,
-        fromAdapter: evmAdapter,
-        toAdapter: evmAdapter
-      }, {
-        onEvent: (evt: any) => {
-           console.log('CCTP Event:', evt)
-           
-           if (evt.type === 'APPROVAL_TX_SENT') setStep('Approving USDC...')
-           if (evt.type === 'BURN_TX_SENT') {
-             setStatus('executing')
-             setStep('Burning USDC...')
-           } 
-           if (evt.step === 'burn' && evt.status === 'complete') {
-             setStep('Waiting for Circle Attestation (~20 mins)...')
-           }
-           if (evt.step === 'mint' && evt.status === 'progress') {
-             setStep('Minting on Destination...')
-           }
+        const burnStep = result.data.steps.find((s) => s.name === 'burn')
+        const tx = burnStep?.txHash
+
+        // Never report success without a real burn tx hash — the bridge is not done
+        // and the server-side poller has nothing to track. Surface the failure.
+        if (!tx) {
+          throw new Error('CCTP burn transaction hash missing — bridge did not complete')
         }
-      })
-      
-      if (!result?.data) throw new Error('CCTP Bridge Failed')
-      
-      const burnStep = result.data.steps.find(s => s.name === 'burn')
-      const tx = burnStep?.txHash
-      
-      if (tx) setTxHash(tx)
-      setStatus('completed')
-      return tx || '0x'
 
-    } catch (e: any) {
-      console.error('CCTP Execution Error:', e)
-      setError(e.message || 'CCTP Failed')
-      setStatus('failed')
-      throw e
-    }
-  }, [walletClient, evmAdapter, executeCCTPBridge])
+        setTxHash(tx)
+        setStatus('completed')
+        return tx
+      } catch (e: any) {
+        console.error('CCTP Execution Error:', e)
+        setError(e.message || 'CCTP Failed')
+        setStatus('failed')
+        throw e
+      }
+    },
+    [walletClient, evmAdapter, executeCCTPBridge],
+  )
 
   //Solana Transaction Signing (Rango serialized tx)
   const executeSolanaTx = useCallback(async (tx: any) => {
@@ -351,7 +386,7 @@ export function useTransactionExecutor() {
       if (!serialized) throw new Error('No serialized Solana transaction data')
 
       const transaction = deserializeSolanaTransaction(serialized)
-      
+
       if (!solana?.signAndSendTransaction) {
         throw new Error('Solana wallet does not support signAndSendTransaction')
       }
@@ -370,68 +405,144 @@ export function useTransactionExecutor() {
     }
   }, [])
 
-  const executeSolanaDeposit = useCallback(async (quote: QuoteResponse) => {
+  // Solana execution for atomic swap providers (primarily LI.FI) that return a
+  // base64 serialized (Versioned)Transaction in transactionRequest.data.
+  const executeLifiSolana = useCallback(async (quote: QuoteResponse) => {
     const solana = (window as any).phantom?.solana || (window as any).solana
-    if (!solana || !address) throw new Error('Solana wallet not connected')
+    if (!solana) throw new Error('Solana wallet not connected')
+    if (!solana.signAndSendTransaction) {
+      throw new Error('Connected Solana wallet does not support signAndSendTransaction.')
+    }
 
-    const depositAddress = quote.metadata?.depositAddress || quote.transactionRequest?.depositAddress
-    if (!depositAddress) throw new Error('No deposit address in quote')
+    const serialized = quote.transactionRequest?.data as string | undefined
+    if (!serialized) throw new Error('No serialized Solana transaction data in quote')
 
     setStatus('executing')
-    setStep('Sending Solana Deposit...')
+    setStep('Signing Solana Transaction...')
 
     try {
-      const fromPubkey = new PublicKey(address)
-      const toPubkey = new PublicKey(depositAddress)
-      const fromToken = quote.routes[0]?.action.fromToken
+      let transaction: VersionedTransaction | Transaction
+      try {
+        transaction = deserializeSolanaTransaction(serialized)
+      } catch {
+        // Fallback: legacy (non-versioned) Solana transaction
+        transaction = Transaction.from(Buffer.from(serialized, 'base64'))
+      }
 
-      let transaction
+      const result = await solana.signAndSendTransaction(transaction)
+      const hash = typeof result === 'string' ? result : result?.signature || result?.toString()
 
-      if (!fromToken || isSolNative(fromToken.address)) {
-        const lamports = BigInt(quote.metadata?.amountToSend || quote.fromAmount)
-        transaction = await buildSolTransfer(fromPubkey, toPubkey, lamports)
-      } else {
-        const mint = new PublicKey(fromToken.address)
-        const amount = BigInt(quote.metadata?.amountToSend || quote.fromAmount)
-        transaction = await buildSplTokenTransfer(fromPubkey, toPubkey, mint, amount)
-      }
+      setTxHash(hash)
+      setStep('Confirming Solana Transaction...')
 
-      let txHash: string
-      if (solana?.signAndSendTransaction) {
-        const result = await solana.signAndSendTransaction(transaction)
-        txHash = typeof result === 'string' ? result : result?.signature || result?.toString()
-      } else {
-        throw new Error('Connected Solana wallet does not support signAndSendTransaction.')
+      try {
+        const connection = getSolanaConnection()
+        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed')
+        await connection.confirmTransaction(
+          { signature: hash, blockhash, lastValidBlockHeight },
+          'confirmed',
+        )
+      } catch (confirmErr) {
+        console.warn('Solana confirmation polling failed (tx may still succeed):', confirmErr)
       }
 
-      setTxHash(txHash)
-      setStep('Deposit Sent. Waiting for swap...')
-
+      // Deposit-based providers (e.g. NEAR via Solana) need the hash submitted to
+      // the solver; LI.FI is self-contained and needs no extra submission.
+      const depositAddress =
+        quote.metadata?.depositAddress || quote.transactionRequest?.depositAddress
       if (quote.provider === 'near-intents' && depositAddress) {
         try {
-          await OneClickService.submitDepositTx({ txHash, depositAddress })
+          await OneClickService.submitDepositTx({
+            txHash: hash,
+            depositAddress: depositAddress as string,
+            memo: quote.metadata?.depositMemo as string | undefined,
+          })
         } catch (e) {
-          console.warn('Failed to submit Solana deposit hash:', e)
+          console.warn('Failed to submit Solana swap hash:', e)
         }
       }
 
       setStatus('completed')
-      return txHash
+      return hash
     } catch (e: any) {
-      console.error('Solana Deposit Error:', e)
-      setError(e.message || 'Solana Deposit Failed')
+      console.error('Solana Swap Execution Error:', e)
+      setError(e.message || 'Solana Swap Execution Failed')
       setStatus('failed')
       throw e
     }
-  }, [address])
+  }, [])
+
+  const executeSolanaDeposit = useCallback(
+    async (quote: QuoteResponse) => {
+      const solana = (window as any).phantom?.solana || (window as any).solana
+      if (!solana || !address) throw new Error('Solana wallet not connected')
+
+      const depositAddress =
+        quote.metadata?.depositAddress || quote.transactionRequest?.depositAddress
+      if (!depositAddress) throw new Error('No deposit address in quote')
+
+      setStatus('executing')
+      setStep('Sending Solana Deposit...')
+
+      try {
+        const fromPubkey = new PublicKey(address)
+        const toPubkey = new PublicKey(depositAddress)
+        const fromToken = quote.routes[0]?.action.fromToken
+
+        let transaction
+
+        if (!fromToken || isSolNative(fromToken.address)) {
+          const lamports = BigInt(quote.metadata?.amountToSend || quote.fromAmount)
+          transaction = await buildSolTransfer(fromPubkey, toPubkey, lamports)
+        } else {
+          const mint = new PublicKey(fromToken.address)
+          const amount = BigInt(quote.metadata?.amountToSend || quote.fromAmount)
+          transaction = await buildSplTokenTransfer(fromPubkey, toPubkey, mint, amount)
+        }
+
+        let txHash: string
+        if (solana?.signAndSendTransaction) {
+          const result = await solana.signAndSendTransaction(transaction)
+          txHash = typeof result === 'string' ? result : result?.signature || result?.toString()
+        } else {
+          throw new Error('Connected Solana wallet does not support signAndSendTransaction.')
+        }
+
+        setTxHash(txHash)
+        setStep('Deposit Sent. Waiting for swap...')
+
+        if (quote.provider === 'near-intents' && depositAddress) {
+          try {
+            await OneClickService.submitDepositTx({
+              txHash,
+              depositAddress,
+              memo: quote.metadata?.depositMemo as string | undefined,
+            })
+          } catch (e) {
+            console.warn('Failed to submit Solana deposit hash:', e)
+          }
+        }
+
+        setStatus('completed')
+        return txHash
+      } catch (e: any) {
+        console.error('Solana Deposit Error:', e)
+        setError(e.message || 'Solana Deposit Failed')
+        setStatus('failed')
+        throw e
+      }
+    },
+    [address],
+  )
 
   const executeBitcoinDeposit = useCallback(async (quote: QuoteResponse) => {
-  
-    const depositAddress = quote.metadata?.depositAddress || quote.transactionRequest?.depositAddress
+    const depositAddress =
+      quote.metadata?.depositAddress || quote.transactionRequest?.depositAddress
     if (!depositAddress) throw new Error('No Bitcoin deposit address in quote')
 
     const btcProvider = (window as any).unisat || (window as any).xfi?.bitcoin
-    if (!btcProvider) throw new Error('Bitcoin wallet not connected. Install a Bitcoin wallet extension.')
+    if (!btcProvider)
+      throw new Error('Bitcoin wallet not connected. Install a Bitcoin wallet extension.')
 
     setStatus('executing')
     setStep('Sending Bitcoin Transaction...')
@@ -439,7 +550,7 @@ export function useTransactionExecutor() {
     try {
       const amountToSend = quote.metadata?.amountToSend || quote.fromAmount
       const satoshis = parseInt(amountToSend as string, 10)
-      
+
       let txHash: string
 
       if (btcProvider?.sendBitcoin) {
@@ -459,7 +570,11 @@ export function useTransactionExecutor() {
 
       if (quote.provider === 'near-intents' && depositAddress) {
         try {
-          await OneClickService.submitDepositTx({ txHash, depositAddress })
+          await OneClickService.submitDepositTx({
+            txHash,
+            depositAddress,
+            memo: quote.metadata?.depositMemo as string | undefined,
+          })
         } catch (e) {
           console.warn('Failed to submit BTC deposit hash:', e)
         }
@@ -476,96 +591,137 @@ export function useTransactionExecutor() {
   }, [])
 
   // Main Entry Point
-  const execute = useCallback(async (quote: QuoteResponse, recipientAddress?: string) => {
-    setError(null)
-    setTxHash(null)
-    
-    try {
-      // Check if this is a non-EVM chain 
-      const chainType = quote.metadata?.chainType || 'evm'
-      const isDepositTrade = quote.metadata?.isDepositTrade
+  const execute = useCallback(
+    async (quote: QuoteResponse, recipientAddress?: string) => {
+      setError(null)
+      setTxHash(null)
 
-      if (isDepositTrade) {
-        if (chainType === 'solana') {
-          return await executeSolanaDeposit(quote)
+      try {
+        // Check if this is a non-EVM chain
+        const chainType = quote.metadata?.chainType || 'evm'
+        const isDepositTrade = quote.metadata?.isDepositTrade
+
+        if (isDepositTrade) {
+          if (chainType === 'solana') {
+            return await executeSolanaDeposit(quote)
+          }
+          if (chainType === 'bitcoin') {
+            return await executeBitcoinDeposit(quote)
+          }
+          // Fund-safety: never let a non-EVM/non-Solana/non-Bitcoin deposit
+          // (XRP/TON/Stellar/Tron/Sui — often memo/tag-required) fall through to
+          // the EVM signer below. We have no working signing path for these, and
+          // misrouting would send funds to a wrong-format address / without the
+          // required memo → unrecoverable loss.
+          if (chainType === 'other') {
+            throw new Error(
+              'Paying from this source chain is not supported yet. ' +
+                'Please choose an EVM, Solana, or Bitcoin source token.',
+            )
+          }
         }
-        if (chainType === 'bitcoin') {
-          return await executeBitcoinDeposit(quote)
+
+        // Non-deposit Solana-source swaps (primarily LI.FI) sign a serialized
+        // Solana transaction. Without this branch they fall through to the EVM
+        // signer below and become unexecutable.
+        if (!isDepositTrade && quote.provider !== 'near-intents' && quote.provider !== 'cctp') {
+          if (resolveExecutionPath(quote) === 'solana') {
+            return await executeLifiSolana(quote)
+          }
         }
-      }
 
-      // EVM execution paths
-      if (quote.provider === 'lifi') {
-        const route = (quote.metadata?.lifiRoute as Route) || quote.routes[0] || quote.transactionRequest
-        return await executeLifi(route) 
-      } 
-      else if (quote.provider === 'rango') {
-        return await executeRango(quote, recipientAddress)
-      }
-      else if (quote.provider === 'near-intents') {
-        return await executeNearIntents(quote)
-      }
-      else if (quote.provider === 'cctp') {
-        return await executeCCTP(quote, recipientAddress)
-      }
-      else {
-        // Atomic Providers (Symbiosis, Rubic)
-        if (!quote.transactionRequest) throw new Error('No transaction request found')
-        
-        if (!walletClient || !publicClient) throw new Error('Wallet not connected')
-
-        // 1. Handle Approvals if needed
-        const approvalAddress = quote.routes[0]?.estimate?.approvalAddress
-        if (approvalAddress && quote.routes[0]?.action?.fromToken?.address !== '0x0000000000000000000000000000000000000000') {
-           const tokenAddress = quote.routes[0].action.fromToken.address as `0x${string}`
-           const amount = BigInt(quote.fromAmount)
-           
-           try {
-             // Check allowance
-             const allowance = await publicClient.readContract({
-               address: tokenAddress,
-               abi: erc20Abi,
-               functionName: 'allowance',
-               args: [walletClient.account.address, approvalAddress as `0x${string}`]
-             }) as bigint
-
-             if (allowance < amount) {
-               setStep('Approving Token...')
-               setStatus('approving')
-               const approveHash = await walletClient.writeContract({
-                 address: tokenAddress,
-                 abi: erc20Abi,
-                 functionName: 'approve',
-                 args: [approvalAddress as `0x${string}`, amount]
-               })
-               
-               setStep('Waiting for Approval...')
-               await publicClient.waitForTransactionReceipt({ hash: approveHash })
-             }
-           } catch (e) {
-             console.warn('Approval check failed, proceeding to tx (might fail):', e)
-           }
+        // EVM execution paths
+        if (quote.provider === 'lifi') {
+          const route =
+            (quote.metadata?.lifiRoute as Route) || quote.routes[0] || quote.transactionRequest
+          return await executeLifi(route)
+        } else if (quote.provider === 'rango') {
+          return await executeRango(quote, recipientAddress)
+        } else if (quote.provider === 'near-intents') {
+          return await executeNearIntents(quote)
+        } else if (quote.provider === 'cctp') {
+          return await executeCCTP(quote, recipientAddress)
+        } else {
+          // Atomic Providers (Symbiosis, Rubic)
+          if (!quote.transactionRequest) throw new Error('No transaction request found')
+
+          if (!walletClient || !publicClient) throw new Error('Wallet not connected')
+
+          // 1. Handle Approvals if needed
+          const approvalAddress = quote.routes[0]?.estimate?.approvalAddress
+          if (
+            approvalAddress &&
+            quote.routes[0]?.action?.fromToken?.address !==
+              '0x0000000000000000000000000000000000000000'
+          ) {
+            const tokenAddress = quote.routes[0].action.fromToken.address as `0x${string}`
+            const amount = BigInt(quote.fromAmount)
+
+            try {
+              // Check allowance
+              const allowance = (await publicClient.readContract({
+                address: tokenAddress,
+                abi: erc20Abi,
+                functionName: 'allowance',
+                args: [walletClient.account.address, approvalAddress as `0x${string}`],
+              })) as bigint
+
+              if (allowance < amount) {
+                setStep('Approving Token...')
+                setStatus('approving')
+                const approveHash = await walletClient.writeContract({
+                  address: tokenAddress,
+                  abi: erc20Abi,
+                  functionName: 'approve',
+                  args: [approvalAddress as `0x${string}`, amount],
+                })
+
+                setStep('Waiting for Approval...')
+                await publicClient.waitForTransactionReceipt({ hash: approveHash })
+              }
+            } catch (e) {
+              console.warn('Approval check failed, proceeding to tx (might fail):', e)
+            }
+          }
+
+          setStatus('executing')
+          setStep('Sending Transaction...')
+
+          const hash = await walletClient.sendTransaction({
+            to: quote.transactionRequest.to as `0x${string}`,
+            data: quote.transactionRequest.data as `0x${string}`,
+            value: BigInt(quote.transactionRequest.value || 0),
+          })
+
+          setTxHash(hash)
+          // Same-chain swaps complete on broadcast; cross-chain bridges (Symbiosis/
+          // Rubic) only settle on the destination minutes later — keep them honest
+          // at 'submitted' and let the server-side poller mark completion.
+          if (isCrossChainSwap(quote)) {
+            setStep('Submitted. Settling on destination chain...')
+            setStatus('submitted')
+          } else {
+            setStatus('completed')
+          }
+          return hash
         }
-        
-        setStatus('executing')
-        setStep('Sending Transaction...')
-        
-        const hash = await walletClient.sendTransaction({
-          to: quote.transactionRequest.to as `0x${string}`,
-          data: quote.transactionRequest.data as `0x${string}`,
-          value: BigInt(quote.transactionRequest.value || 0),
-        })
-        
-        setTxHash(hash)
-        setStatus('completed')
-        return hash
+      } catch (e: any) {
+        setError(e.message)
+        setStatus('failed')
+        throw e
       }
-    } catch (e: any) {
-       setError(e.message)
-       setStatus('failed')
-       throw e
-    }
-  }, [executeLifi, executeRango, executeNearIntents, executeSolanaDeposit, executeBitcoinDeposit, walletClient, publicClient])
+    },
+    [
+      executeLifi,
+      executeRango,
+      executeNearIntents,
+      executeLifiSolana,
+      executeSolanaDeposit,
+      executeBitcoinDeposit,
+      walletClient,
+      publicClient,
+    ],
+  )
 
   return { execute, status, error, txHash, step }
 }
diff --git a/src/inngest/functions/poll-transaction.ts b/src/inngest/functions/poll-transaction.ts
index 7761e09..6773502 100644
--- a/src/inngest/functions/poll-transaction.ts
+++ b/src/inngest/functions/poll-transaction.ts
@@ -55,7 +55,7 @@ export const pollTransactionStatus = inngest.createFunction(
   { id: 'poll-transaction-status' },
   { event: 'transaction/poll' },
   async ({ event, step }) => {
-    const { transactionId, txHash, fromChainId, toChainId, bridge, provider: providerName, requestId, depositAddress, attempt = 1 } = event.data
+    const { transactionId, txHash, fromChainId, toChainId, bridge, provider: providerName, requestId, depositAddress, depositMemo, attempt = 1 } = event.data
 
     // Skip if no txHash yet
     if (!txHash) {
@@ -99,6 +99,7 @@ export const pollTransactionStatus = inngest.createFunction(
         bridge,
         requestId, // For Rango
         depositAddress, // For Near Intents
+        depositMemo, // For memo-required NEAR deposit chains
       }
       return provider.getStatus(request)
     })
diff --git a/src/lib/__tests__/chain-address.test.ts b/src/lib/__tests__/chain-address.test.ts
new file mode 100644
index 0000000..55af322
--- /dev/null
+++ b/src/lib/__tests__/chain-address.test.ts
@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest'
+import { isValidAddressForChain, validateQuoteRequest } from '../chain-address'
+
+describe('isValidAddressForChain', () => {
+  it('accepts a valid EVM address on an evm chain', () => {
+    expect(isValidAddressForChain('0x1111111111111111111111111111111111111111', 1)).toBe(true)
+    expect(isValidAddressForChain('0xaF88d065e77c8cC2239327C5EDb3A432268e5831', 42161)).toBe(true)
+  })
+
+  it('rejects a non-EVM address on an evm chain', () => {
+    expect(isValidAddressForChain('4Nd1mYsL-not-an-evm-addr', 1)).toBe(false)
+    expect(isValidAddressForChain('0x123', 1)).toBe(false)
+    expect(isValidAddressForChain('0x11111111111111111111111111111111111111', 1)).toBe(false)
+  })
+
+  it('accepts a valid Solana (base58) address on solana', () => {
+    expect(isValidAddressForChain('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', 'solana')).toBe(
+      true,
+    )
+  })
+
+  it('rejects an EVM 0x address on solana', () => {
+    expect(isValidAddressForChain('0x1111111111111111111111111111111111111111', 'solana')).toBe(
+      false,
+    )
+  })
+
+  it('accepts valid Bitcoin addresses (bech32 and legacy) on bitcoin', () => {
+    expect(isValidAddressForChain('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'bitcoin')).toBe(
+      true,
+    )
+    expect(isValidAddressForChain('1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa', 'bitcoin')).toBe(true)
+    expect(isValidAddressForChain('3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy', 'bitcoin')).toBe(true)
+  })
+
+  it('rejects an EVM 0x address on bitcoin', () => {
+    expect(isValidAddressForChain('0x1111111111111111111111111111111111111111', 'bitcoin')).toBe(
+      false,
+    )
+  })
+
+  it("returns true for 'other'-family chains (A5 handles those)", () => {
+    expect(isValidAddressForChain('anything-goes', 'stellar')).toBe(true)
+    expect(isValidAddressForChain('rXYZ', 'xrp')).toBe(true)
+  })
+
+  it('allows empty/whitespace addresses through (quotes without a wallet)', () => {
+    expect(isValidAddressForChain('', 1)).toBe(true)
+    expect(isValidAddressForChain('   ', 1)).toBe(true)
+    expect(isValidAddressForChain('', 'solana')).toBe(true)
+  })
+})
+
+describe('validateQuoteRequest', () => {
+  it('returns ok for a valid evm->evm request', () => {
+    expect(
+      validateQuoteRequest({
+        fromChain: 42161,
+        toChain: 8453,
+        fromAddress: '0x1111111111111111111111111111111111111111',
+        toAddress: '0x2222222222222222222222222222222222222222',
+      }),
+    ).toEqual({ ok: true })
+  })
+
+  it('returns ok when addresses are missing', () => {
+    expect(validateQuoteRequest({ fromChain: 1, toChain: 1 })).toEqual({ ok: true })
+  })
+
+  it('flags an exotic source chain as unsupported', () => {
+    const r = validateQuoteRequest({ fromChain: 'stellar', toChain: 8453 })
+    expect(r.ok).toBe(false)
+    if (!r.ok) {
+      expect(r.unsupported).toBe(true)
+      expect(r.reason).toMatch(/stellar/i)
+    }
+  })
+
+  it('flags an exotic destination chain as unsupported', () => {
+    const r = validateQuoteRequest({ fromChain: 1, toChain: 'xrp' })
+    expect(r.ok).toBe(false)
+    if (!r.ok) expect(r.unsupported).toBe(true)
+  })
+
+  it('runs the unsupported check BEFORE the address check', () => {
+    const r = validateQuoteRequest({
+      fromChain: 'stellar',
+      toChain: 8453,
+      fromAddress: 'totally-bogus',
+    })
+    expect(r.ok).toBe(false)
+    if (!r.ok) expect(r.unsupported).toBe(true)
+  })
+
+  it('flags a mismatched fromAddress as invalid (not unsupported)', () => {
+    const r = validateQuoteRequest({
+      fromChain: 1,
+      toChain: 1,
+      fromAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+    })
+    expect(r.ok).toBe(false)
+    if (!r.ok) {
+      expect(r.unsupported).toBeFalsy()
+      expect(r.reason).toMatch(/source address/i)
+    }
+  })
+
+  it('flags a mismatched toAddress as invalid (not unsupported)', () => {
+    const r = validateQuoteRequest({
+      fromChain: 1,
+      toChain: 'solana',
+      fromAddress: '0x1111111111111111111111111111111111111111',
+      toAddress: '0x2222222222222222222222222222222222222222',
+    })
+    expect(r.ok).toBe(false)
+    if (!r.ok) {
+      expect(r.unsupported).toBeFalsy()
+      expect(r.reason).toMatch(/destination address/i)
+    }
+  })
+})
diff --git a/src/lib/__tests__/chain-family.test.ts b/src/lib/__tests__/chain-family.test.ts
new file mode 100644
index 0000000..bc9351b
--- /dev/null
+++ b/src/lib/__tests__/chain-family.test.ts
@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest'
+import { deriveChainFamily, isExecutableDepositFamily } from '../chain-family'
+
+describe('deriveChainFamily', () => {
+  it('numeric chainId → evm', () => {
+    expect(deriveChainFamily(1)).toBe('evm')
+    expect(deriveChainFamily(42161)).toBe('evm')
+  })
+
+  it('numeric string chainId → evm', () => {
+    expect(deriveChainFamily('137')).toBe('evm')
+    expect(deriveChainFamily('8453')).toBe('evm')
+  })
+
+  it('solana keys → solana', () => {
+    expect(deriveChainFamily('solana')).toBe('solana')
+    expect(deriveChainFamily('sol')).toBe('solana')
+  })
+
+  it('bitcoin keys → bitcoin', () => {
+    expect(deriveChainFamily('bitcoin')).toBe('bitcoin')
+    expect(deriveChainFamily('btc')).toBe('bitcoin')
+  })
+
+  it('exotic / memo-required chains → other (NOT evm — this is the fund-loss guard)', () => {
+    for (const c of ['xrp', 'ton', 'stellar', 'xlm', 'tron', 'sui', 'dogecoin', 'near', 'aptos', 'cosmos']) {
+      expect(deriveChainFamily(c), c).toBe('other')
+    }
+  })
+
+  it('is case-insensitive', () => {
+    expect(deriveChainFamily('SOLANA')).toBe('solana')
+    expect(deriveChainFamily('XRP')).toBe('other')
+  })
+})
+
+describe('isExecutableDepositFamily', () => {
+  it('evm/solana/bitcoin are executable', () => {
+    expect(isExecutableDepositFamily('evm')).toBe(true)
+    expect(isExecutableDepositFamily('solana')).toBe(true)
+    expect(isExecutableDepositFamily('bitcoin')).toBe(true)
+  })
+
+  it('other is NOT executable (must be blocked, not misrouted)', () => {
+    expect(isExecutableDepositFamily('other')).toBe(false)
+  })
+})
diff --git a/src/lib/__tests__/execution-path.test.ts b/src/lib/__tests__/execution-path.test.ts
new file mode 100644
index 0000000..b46b11d
--- /dev/null
+++ b/src/lib/__tests__/execution-path.test.ts
@@ -0,0 +1,174 @@
+import { describe, it, expect } from 'vitest'
+import { resolveExecutionPath, isCrossChainSwap } from '../execution-path'
+import type { QuoteResponse } from '@/types/provider'
+
+function quoteFromTo(fromChainId: number | string, toChainId: number | string): QuoteResponse {
+  return {
+    provider: 'symbiosis',
+    id: 'q1',
+    fromAmount: '1000',
+    toAmount: '1000',
+    toAmountMin: '1000',
+    estimatedGas: '0',
+    estimatedDuration: 60,
+    routes: [
+      {
+        type: 'bridge',
+        tool: 't',
+        action: {
+          fromToken: { address: '0xabc', chainId: fromChainId, symbol: 'X', decimals: 18 },
+          toToken: { address: '0xdef', chainId: toChainId, symbol: 'Y', decimals: 6 },
+          fromAmount: '1000',
+          toAmount: '1000',
+        },
+        estimate: {},
+      },
+    ],
+  } as QuoteResponse
+}
+
+function makeQuote(overrides: Partial<QuoteResponse>): QuoteResponse {
+  return {
+    provider: 'lifi',
+    id: 'q1',
+    fromAmount: '1000000',
+    toAmount: '990000',
+    toAmountMin: '980000',
+    estimatedGas: '0',
+    estimatedDuration: 60,
+    toolsUsed: [],
+    routes: [],
+    ...overrides,
+  } as QuoteResponse
+}
+
+describe('resolveExecutionPath', () => {
+  it('routes near-intents quotes to the near path', () => {
+    const quote = makeQuote({ provider: 'near-intents' })
+    expect(resolveExecutionPath(quote)).toBe('near')
+  })
+
+  it('routes a LiFi Solana-source quote to the solana path (via metadata.chainType)', () => {
+    const quote = makeQuote({
+      provider: 'lifi',
+      metadata: { chainType: 'solana' },
+      routes: [
+        {
+          type: 'swap',
+          tool: 'jupiter',
+          action: {
+            fromToken: { address: 'So111', chainId: 1151111081099710, symbol: 'SOL', decimals: 9 },
+            toToken: { address: '0xabc', chainId: 8453, symbol: 'USDC', decimals: 6 },
+            fromAmount: '1000000000',
+            toAmount: '990000',
+          },
+          estimate: {},
+        },
+      ],
+    })
+    expect(resolveExecutionPath(quote)).toBe('solana')
+  })
+
+  it('routes a non-NEAR Solana-source quote to the solana path (via string chain id)', () => {
+    const quote = makeQuote({
+      provider: 'rubic',
+      routes: [
+        {
+          type: 'bridge',
+          tool: 'rubic',
+          action: {
+            fromToken: { address: 'So111', chainId: 'solana', symbol: 'SOL', decimals: 9 },
+            toToken: { address: '0xabc', chainId: 8453, symbol: 'USDC', decimals: 6 },
+            fromAmount: '1000000000',
+            toAmount: '990000',
+          },
+          estimate: {},
+        },
+      ],
+    })
+    expect(resolveExecutionPath(quote)).toBe('solana')
+  })
+
+  it('does NOT send a LiFi Solana-source quote to the evm path', () => {
+    const quote = makeQuote({
+      provider: 'lifi',
+      metadata: { chainType: 'solana' },
+      routes: [
+        {
+          type: 'swap',
+          tool: 'jupiter',
+          action: {
+            fromToken: { address: 'So111', chainId: 1151111081099710, symbol: 'SOL', decimals: 9 },
+            toToken: { address: '0xabc', chainId: 8453, symbol: 'USDC', decimals: 6 },
+            fromAmount: '1000000000',
+            toAmount: '990000',
+          },
+          estimate: {},
+        },
+      ],
+    })
+    expect(resolveExecutionPath(quote)).not.toBe('evm')
+  })
+
+  it('routes an EVM LiFi quote to the evm path', () => {
+    const quote = makeQuote({
+      provider: 'lifi',
+      metadata: { chainType: 'evm' },
+      routes: [
+        {
+          type: 'swap',
+          tool: 'uniswap',
+          action: {
+            fromToken: { address: '0xdef', chainId: 1, symbol: 'WETH', decimals: 18 },
+            toToken: { address: '0xabc', chainId: 8453, symbol: 'USDC', decimals: 6 },
+            fromAmount: '1000000000000000000',
+            toAmount: '990000',
+          },
+          estimate: {},
+        },
+      ],
+    })
+    expect(resolveExecutionPath(quote)).toBe('evm')
+  })
+
+  it('blocks a deposit-trade quote from an unsupported (other) source chain', () => {
+    const quote = makeQuote({
+      provider: 'rubic',
+      metadata: { chainType: 'other', isDepositTrade: true },
+    })
+    expect(resolveExecutionPath(quote)).toBe('blocked')
+  })
+
+  it('routes a bitcoin deposit-trade quote to the bitcoin path', () => {
+    const quote = makeQuote({
+      provider: 'symbiosis',
+      metadata: { chainType: 'bitcoin', isDepositTrade: true },
+    })
+    expect(resolveExecutionPath(quote)).toBe('bitcoin')
+  })
+
+  it('routes a solana deposit-trade quote to the solana path', () => {
+    const quote = makeQuote({
+      provider: 'rubic',
+      metadata: { chainType: 'solana', isDepositTrade: true },
+    })
+    expect(resolveExecutionPath(quote)).toBe('solana')
+  })
+})
+
+describe('isCrossChainSwap', () => {
+  it('true when source and destination chains differ (Arb -> Base)', () => {
+    expect(isCrossChainSwap(quoteFromTo(42161, 8453))).toBe(true)
+  })
+  it('false for a same-chain swap (Arb -> Arb)', () => {
+    expect(isCrossChainSwap(quoteFromTo(42161, 42161))).toBe(false)
+  })
+  it('treats numeric and numeric-string chain ids as equal (no false cross-chain)', () => {
+    expect(isCrossChainSwap(quoteFromTo(42161, '42161'))).toBe(false)
+  })
+  it('false when route chain ids are missing (cannot prove cross-chain)', () => {
+    const q = quoteFromTo(1, 1)
+    q.routes = []
+    expect(isCrossChainSwap(q)).toBe(false)
+  })
+})
diff --git a/src/lib/__tests__/quote-aggregator.test.ts b/src/lib/__tests__/quote-aggregator.test.ts
index 3cd6ad5..a130065 100644
--- a/src/lib/__tests__/quote-aggregator.test.ts
+++ b/src/lib/__tests__/quote-aggregator.test.ts
@@ -1,16 +1,15 @@
 /**
- * Tests for pure utility functions extracted from the quote aggregator.
+ * Tests for the pure chain-alias normalization used by the quote aggregator.
  *
- * We cannot import the QuoteAggregator directly because it pulls in providers
- * with heavy SDK deps (LiFi, Rango, etc). Instead we test the exported pure logic:
- * normalizeChainId, calculateTieBreakerScore, rankQuotes
- *
- * These are rewritten here since they're not exported from the module.
- * If they get exported in the future, switch to direct imports.
+ * NOTE: quote RANKING is now tested in src/services/__tests__/ranking.test.ts
+ * against the real `ranking.ts` module. This file previously re-implemented the
+ * OLD raw-BigInt(toAmount) ranking inline; that logic was replaced (it ranked
+ * mislabeled-decimals quotes as best) so those duplicated tests were removed to
+ * avoid a maintenance trap. Only the still-valid normalizeChainId tests remain.
  */
 import { describe, it, expect } from 'vitest'
 
-// ─── Recreate pure functions from quote-aggregator ────────────────
+// ─── Recreate the pure normalizeChainId from quote-aggregator ──────
 
 const CHAIN_ID_ALIASES: Record<string, string> = {
   sol: 'solana',
@@ -30,52 +29,6 @@ function normalizeChainId(id: ChainId): ChainId {
   return id
 }
 
-const PROVIDER_RELIABILITY: Record<string, number> = {
-  'cctp': 98,
-  'lifi': 95,
-  'rango': 90,
-  'symbiosis': 88,
-  'rubic': 85,
-  'near-intents': 80,
-}
-
-interface MockQuote {
-  provider: string
-  toAmount: string
-  fees?: { totalFeeUSD?: string }
-  estimatedGas?: string
-  estimatedDuration?: number
-}
-
-function calculateTieBreakerScore(quote: MockQuote): number {
-  const totalFeeUSD = parseFloat(quote.fees?.totalFeeUSD || '0')
-  const gasCostUSD = parseFloat(quote.estimatedGas || '0')
-  const duration = quote.estimatedDuration || 600
-  const reliability = PROVIDER_RELIABILITY[quote.provider] || 50
-
-  const totalCost = totalFeeUSD + gasCostUSD
-  const feeScore = Math.max(0, 30 * (1 - Math.min(totalCost, 30) / 30))
-  const speedScore = Math.max(0, 10 * (1 - Math.min(duration, 1800) / 1800))
-  const reliabilityScore = (reliability / 100) * 10
-
-  return feeScore + speedScore + reliabilityScore
-}
-
-function rankQuotes(quotes: MockQuote[]): MockQuote[] {
-  return [...quotes].sort((a, b) => {
-    const amountA = BigInt(a.toAmount || '0')
-    const amountB = BigInt(b.toAmount || '0')
-
-    if (amountA !== amountB) {
-      return amountA > amountB ? -1 : 1
-    }
-
-    return calculateTieBreakerScore(b) - calculateTieBreakerScore(a)
-  })
-}
-
-// ─── normalizeChainId ─────────────────────────────────────────────
-
 describe('normalizeChainId', () => {
   it('maps "sol" → "solana"', () => {
     expect(normalizeChainId('sol')).toBe('solana')
@@ -103,82 +56,3 @@ describe('normalizeChainId', () => {
     expect(normalizeChainId('ethereum')).toBe('ethereum')
   })
 })
-
-// ─── calculateTieBreakerScore ─────────────────────────────────────
-
-describe('calculateTieBreakerScore', () => {
-  it('higher reliability = higher score (same fees/speed)', () => {
-    const cctp = calculateTieBreakerScore({ provider: 'cctp', toAmount: '100', estimatedDuration: 300 })
-    const rubic = calculateTieBreakerScore({ provider: 'rubic', toAmount: '100', estimatedDuration: 300 })
-    expect(cctp).toBeGreaterThan(rubic)
-  })
-
-  it('lower fees = higher score', () => {
-    const lowFee = calculateTieBreakerScore({
-      provider: 'lifi', toAmount: '100',
-      fees: { totalFeeUSD: '1' }, estimatedGas: '0',
-    })
-    const highFee = calculateTieBreakerScore({
-      provider: 'lifi', toAmount: '100',
-      fees: { totalFeeUSD: '25' }, estimatedGas: '0',
-    })
-    expect(lowFee).toBeGreaterThan(highFee)
-  })
-
-  it('faster routes score higher', () => {
-    const fast = calculateTieBreakerScore({
-      provider: 'lifi', toAmount: '100', estimatedDuration: 60,
-    })
-    const slow = calculateTieBreakerScore({
-      provider: 'lifi', toAmount: '100', estimatedDuration: 1800,
-    })
-    expect(fast).toBeGreaterThan(slow)
-  })
-
-  it('returns non-negative for worst-case inputs', () => {
-    const score = calculateTieBreakerScore({
-      provider: 'unknown', toAmount: '0',
-      fees: { totalFeeUSD: '999' }, estimatedGas: '999', estimatedDuration: 99999,
-    })
-    expect(score).toBeGreaterThanOrEqual(0)
-  })
-})
-
-// ─── rankQuotes ───────────────────────────────────────────────────
-
-describe('rankQuotes', () => {
-  it('ranks by output amount (highest first)', () => {
-    const quotes: MockQuote[] = [
-      { provider: 'rubic', toAmount: '100' },
-      { provider: 'lifi', toAmount: '200' },
-      { provider: 'rango', toAmount: '150' },
-    ]
-
-    const ranked = rankQuotes(quotes)
-    expect(ranked[0].provider).toBe('lifi')
-    expect(ranked[1].provider).toBe('rango')
-    expect(ranked[2].provider).toBe('rubic')
-  })
-
-  it('uses tie-breaker when amounts are equal', () => {
-    const quotes: MockQuote[] = [
-      { provider: 'rubic', toAmount: '100', fees: { totalFeeUSD: '10' } },
-      { provider: 'cctp', toAmount: '100', fees: { totalFeeUSD: '1' } },
-    ]
-
-    const ranked = rankQuotes(quotes)
-    // cctp has higher reliability AND lower fees
-    expect(ranked[0].provider).toBe('cctp')
-  })
-
-  it('handles single quote', () => {
-    const quotes: MockQuote[] = [{ provider: 'lifi', toAmount: '500' }]
-    const ranked = rankQuotes(quotes)
-    expect(ranked).toHaveLength(1)
-    expect(ranked[0].provider).toBe('lifi')
-  })
-
-  it('handles empty array', () => {
-    expect(rankQuotes([])).toEqual([])
-  })
-})
diff --git a/src/lib/__tests__/token-filter.test.ts b/src/lib/__tests__/token-filter.test.ts
index 38e33d4..554f555 100644
--- a/src/lib/__tests__/token-filter.test.ts
+++ b/src/lib/__tests__/token-filter.test.ts
@@ -4,7 +4,10 @@ import {
   filterSpamTokens,
   STABLECOIN_SYMBOLS,
   MAX_SYMBOL_LENGTH,
+  normalizeSymbolKey,
+  collapseTokensBySymbol,
 } from '../token-filter'
+import type { UnifiedToken } from '../chain-registry'
 
 // ─── Helpers ───────────────────────────────────────────────────────
 
@@ -167,3 +170,112 @@ describe('filterSpamTokens', () => {
     expect(result[0].symbol).toBe('WETH')
   })
 })
+
+// ─── normalizeSymbolKey ───────────────────────────────────────────
+
+describe('normalizeSymbolKey', () => {
+  it('uppercases plain symbols', () => {
+    expect(normalizeSymbolKey('usdc')).toBe('USDC')
+    expect(normalizeSymbolKey('Weth')).toBe('WETH')
+  })
+
+  it('folds known bridged stablecoin variants to their base', () => {
+    expect(normalizeSymbolKey('USDC.e')).toBe('USDC')
+    expect(normalizeSymbolKey('usdbc')).toBe('USDC')
+    expect(normalizeSymbolKey('fUSDT')).toBe('USDT')
+  })
+
+  it('does not fold non-stablecoin lookalikes', () => {
+    expect(normalizeSymbolKey('WETH.e')).toBe('WETH.E')
+    expect(normalizeSymbolKey('SOL')).toBe('SOL')
+  })
+
+  it('handles empty symbol', () => {
+    expect(normalizeSymbolKey('')).toBe('')
+  })
+})
+
+// ─── collapseTokensBySymbol ───────────────────────────────────────
+
+describe('collapseTokensBySymbol', () => {
+  const t = (over: Partial<UnifiedToken>): UnifiedToken => ({
+    address: '0x0',
+    symbol: 'X',
+    name: 'X',
+    decimals: 18,
+    chainKey: '1',
+    ...over,
+  })
+
+  it('collapses multiple same-symbol USDC into one row', () => {
+    const tokens = [
+      t({ address: '0xAAA', symbol: 'USDC', name: 'USD Coin' }),
+      t({ address: '0xBBB', symbol: 'USDC', name: 'USD Coin (provider 2)' }),
+      t({ address: '0xCCC', symbol: 'USDC', name: 'USD Coin (provider 3)' }),
+    ]
+    const result = collapseTokensBySymbol(tokens)
+    expect(result.filter((x) => x.symbol.toUpperCase() === 'USDC')).toHaveLength(1)
+  })
+
+  it('prefers the canonical address when collapsing', () => {
+    const canonicalAddr = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' // Ethereum USDC
+    const tokens = [
+      t({ address: '0xSPAM', symbol: 'USDC', name: 'Fake USDC' }),
+      t({ address: canonicalAddr, symbol: 'USDC', name: 'USD Coin' }),
+    ]
+    const result = collapseTokensBySymbol(tokens, '1')
+    const usdc = result.find((x) => x.symbol === 'USDC')
+    expect(usdc?.address).toBe(canonicalAddr)
+  })
+
+  it('hides USDC.e when canonical USDC is present (base symbol wins)', () => {
+    const tokens = [
+      t({ address: '0xUSDC', symbol: 'USDC', name: 'USD Coin' }),
+      t({ address: '0xBRIDGED', symbol: 'USDC.e', name: 'Bridged USDC' }),
+    ]
+    const result = collapseTokensBySymbol(tokens)
+    const usdcFamily = result.filter((x) => normalizeSymbolKey(x.symbol) === 'USDC')
+    expect(usdcFamily).toHaveLength(1)
+    expect(usdcFamily[0].symbol).toBe('USDC')
+  })
+
+  it('keeps USDC.e when no plain USDC exists (never drops a whole family)', () => {
+    const tokens = [t({ address: '0xBRIDGED', symbol: 'USDC.e', name: 'Bridged USDC' })]
+    const result = collapseTokensBySymbol(tokens)
+    expect(result).toHaveLength(1)
+    expect(result[0].symbol).toBe('USDC.e')
+  })
+
+  it('collapses multiple native SOL entries into one', () => {
+    const tokens = [
+      t({ address: '11111111111111111111111111111111', symbol: 'SOL', name: 'Solana', isNative: true, chainKey: 'solana' }),
+      t({ address: 'So11111111111111111111111111111111111111112', symbol: 'SOL', name: 'Wrapped SOL', isNative: true, chainKey: 'solana' }),
+    ]
+    const result = collapseTokensBySymbol(tokens, 'solana')
+    expect(result.filter((x) => x.symbol === 'SOL')).toHaveLength(1)
+  })
+
+  it('prefers higher provider count when no canonical/native distinction', () => {
+    const tokens = [
+      t({ address: '0xLOW', symbol: 'WIF', name: 'dogwifhat', logoUrl: 'l', providerIds: { _count: 1 } as never }),
+      t({ address: '0xHIGH', symbol: 'WIF', name: 'dogwifhat', logoUrl: 'l', providerIds: { _count: 3 } as never }),
+    ]
+    const result = collapseTokensBySymbol(tokens)
+    expect(result).toHaveLength(1)
+    expect(result[0].address).toBe('0xHIGH')
+  })
+
+  it('leaves distinct symbols untouched', () => {
+    const tokens = [
+      t({ address: '0x1', symbol: 'USDC', name: 'USD Coin' }),
+      t({ address: '0x2', symbol: 'USDT', name: 'Tether' }),
+      t({ address: '0x3', symbol: 'WETH', name: 'Wrapped Ether' }),
+    ]
+    const result = collapseTokensBySymbol(tokens)
+    expect(result).toHaveLength(3)
+  })
+
+  it('handles empty input', () => {
+    expect(collapseTokensBySymbol([])).toEqual([])
+  })
+})
diff --git a/src/lib/api/get-tokens.ts b/src/lib/api/get-tokens.ts
index 643bfcd..f47250c 100644
--- a/src/lib/api/get-tokens.ts
+++ b/src/lib/api/get-tokens.ts
@@ -1,6 +1,7 @@
 import { ChainTokenService } from '@/services/chain-token-service'
 import { TOKENS } from '@/lib/tokens'
-import { isSpamToken, buildCanonicalAddresses } from '@/lib/token-filter'
+import { isSpamToken, buildCanonicalAddresses, collapseTokensBySymbol } from '@/lib/token-filter'
+import type { UnifiedToken } from '@/lib/chain-registry'
 
 /** Shape of a row in the cached_tokens Supabase table */
 interface CachedTokenRow {
@@ -67,7 +68,7 @@ export async function getTokens(supabase: SupabaseClient, chainKey: string) {
 
     // Filter spam from cached data (catches pre-existing unfiltered tokens)
     const spamCanonical = buildCanonicalAddresses(chainKey)
-    const mapped = rawMapped.filter((t) => {
+    let mapped = rawMapped.filter((t) => {
       const count =
         t.providerIds && typeof (t.providerIds as Record<string, unknown>)._count === 'number'
           ? ((t.providerIds as Record<string, unknown>)._count as number)
@@ -94,6 +95,14 @@ export async function getTokens(supabase: SupabaseClient, chainKey: string) {
       }
     }
 
+    // Collapse same-symbol variants (USDC/USDC.e, un-deduped native SOL rows)
+    // into one canonical row per symbol — the cache table stores one row per
+    // address, so this is where the duplicate USDC/SOL entries get merged.
+    mapped = collapseTokensBySymbol(
+      mapped as unknown as UnifiedToken[],
+      chainKey,
+    ) as unknown as MappedToken[]
+
     // Provider count: stored as _count in providerIds by mergeTokens(), or count object keys
     const getProviderCount = (t: MappedToken) => {
       if (!t.providerIds || typeof t.providerIds !== 'object') return 0
diff --git a/src/lib/chain-address.ts b/src/lib/chain-address.ts
new file mode 100644
index 0000000..1646806
--- /dev/null
+++ b/src/lib/chain-address.ts
@@ -0,0 +1,81 @@
+import type { ChainId } from '@/types/provider'
+import { deriveChainFamily } from './chain-family'
+
+const EVM_ADDRESS = /^0x[0-9a-fA-F]{40}$/
+const SOLANA_ADDRESS = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/
+const BTC_BECH32 = /^(bc1|tb1)[02-9ac-hj-np-z]{6,87}$/i
+const BTC_LEGACY = /^[13mn2][a-km-zA-HJ-NP-Z1-9]{25,39}$/
+
+/**
+ * Whether `address` is a syntactically valid address for `chain`'s wallet family.
+ * Empty/whitespace addresses are allowed (quotes can be requested without a
+ * connected wallet). 'other'-family chains return true here — A5 (unsupported)
+ * handles them so we don't double-reject.
+ */
+export function isValidAddressForChain(address: string, chain: ChainId): boolean {
+  const addr = (address ?? '').trim()
+  if (addr === '') return true
+
+  const family = deriveChainFamily(chain)
+  switch (family) {
+    case 'evm':
+      return EVM_ADDRESS.test(addr)
+    case 'solana':
+      return !addr.startsWith('0x') && SOLANA_ADDRESS.test(addr)
+    case 'bitcoin':
+      return BTC_BECH32.test(addr) || BTC_LEGACY.test(addr)
+    default:
+      return true
+  }
+}
+
+export type ValidateQuoteResult =
+  | { ok: true }
+  | { ok: false; unsupported?: boolean; reason: string }
+
+/**
+ * Pure central validation for a quote request. Surfaces 'other'-family chains
+ * as `unsupported` (no executable signing path — see chain-family / N2) BEFORE
+ * address validation, so an exotic chain reads as "unsupported" rather than
+ * "bad address". Then rejects addresses that don't match the chain's address
+ * space.
+ */
+export function validateQuoteRequest(req: {
+  fromChain: ChainId
+  toChain: ChainId
+  fromAddress?: string
+  toAddress?: string
+}): ValidateQuoteResult {
+  const fromFamily = deriveChainFamily(req.fromChain)
+  const toFamily = deriveChainFamily(req.toChain)
+
+  if (fromFamily === 'other') {
+    return {
+      ok: false,
+      unsupported: true,
+      reason: `Source chain "${req.fromChain}" is not supported for payments yet.`,
+    }
+  }
+  if (toFamily === 'other') {
+    return {
+      ok: false,
+      unsupported: true,
+      reason: `Destination chain "${req.toChain}" is not supported for payments yet.`,
+    }
+  }
+
+  if (req.fromAddress && !isValidAddressForChain(req.fromAddress, req.fromChain)) {
+    return {
+      ok: false,
+      reason: `Source address is not a valid ${fromFamily} address for this chain.`,
+    }
+  }
+  if (req.toAddress && !isValidAddressForChain(req.toAddress, req.toChain)) {
+    return {
+      ok: false,
+      reason: `Destination address is not a valid ${toFamily} address for this chain.`,
+    }
+  }
+
+  return { ok: true }
+}
diff --git a/src/lib/chain-family.ts b/src/lib/chain-family.ts
new file mode 100644
index 0000000..690b76e
--- /dev/null
+++ b/src/lib/chain-family.ts
@@ -0,0 +1,33 @@
+import type { ChainId } from '@/types/provider'
+
+/**
+ * The wallet family the app can actually sign a deposit/transaction with.
+ * 'other' means we have NO working signing path for that chain today — and
+ * several such chains (XRP, TON, Stellar) REQUIRE a memo/tag we can't safely
+ * attach. Callers MUST block execution for 'other' rather than misroute it to
+ * the EVM signer (which would send funds with a wrong-format address / no memo
+ * → unrecoverable loss).
+ */
+export type ChainFamily = 'evm' | 'solana' | 'bitcoin' | 'other'
+
+const SOLANA_KEYS = new Set(['solana', 'sol'])
+const BITCOIN_KEYS = new Set(['bitcoin', 'btc'])
+
+/**
+ * Map a chain identifier (numeric chainId or string key) to its executable
+ * wallet family. Numeric (or numeric-string) ids are EVM; 'solana'/'bitcoin'
+ * map to themselves; everything else is 'other'.
+ */
+export function deriveChainFamily(chain: ChainId): ChainFamily {
+  if (typeof chain === 'number') return 'evm'
+  const s = String(chain).toLowerCase().trim()
+  if (/^\d+$/.test(s)) return 'evm'
+  if (SOLANA_KEYS.has(s)) return 'solana'
+  if (BITCOIN_KEYS.has(s)) return 'bitcoin'
+  return 'other'
+}
+
+/** Whether a deposit can be executed for this family with a real wallet today. */
+export function isExecutableDepositFamily(family: ChainFamily): boolean {
+  return family === 'evm' || family === 'solana' || family === 'bitcoin'
+}
diff --git a/src/lib/execution-path.ts b/src/lib/execution-path.ts
new file mode 100644
index 0000000..da5837c
--- /dev/null
+++ b/src/lib/execution-path.ts
@@ -0,0 +1,47 @@
+import type { QuoteResponse } from '@/types/provider'
+import { deriveChainFamily } from './chain-family'
+
+/**
+ * The execution branch the transaction executor should dispatch a quote to.
+ * 'blocked' means we have no safe signing path for the source chain and must
+ * refuse rather than misroute funds.
+ */
+export type ExecutionPath = 'near' | 'solana' | 'bitcoin' | 'evm' | 'blocked'
+
+/**
+ * Resolve which execution branch a quote belongs to.
+ *
+ * Solana detection is intentionally tolerant: LiFi reports its Solana chain id
+ * as a numeric value (1151111081099710), which deriveChainFamily classifies as
+ * 'evm', so we also honor the provider-set metadata.chainType. Without this, a
+ * LiFi Solana-source quote would fall through to the EVM signer and be
+ * unexecutable.
+ */
+export function resolveExecutionPath(quote: QuoteResponse): ExecutionPath {
+  if (quote.provider === 'near-intents') return 'near'
+
+  const chainType = quote.metadata?.chainType as string | undefined
+  const sourceFamily = deriveChainFamily(quote.routes?.[0]?.action?.fromToken?.chainId ?? '')
+
+  if (chainType === 'solana' || sourceFamily === 'solana') return 'solana'
+  if (chainType === 'bitcoin' || sourceFamily === 'bitcoin') return 'bitcoin'
+
+  if (quote.metadata?.isDepositTrade && chainType === 'other') return 'blocked'
+
+  return 'evm'
+}
+
+/**
+ * True when a quote bridges across two different chains. For atomic providers
+ * (Symbiosis/Rubic) broadcasting the source tx does NOT mean the swap finished:
+ * a cross-chain bridge settles on the destination minutes later. Callers must
+ * not claim 'completed' on broadcast for these — the server-side poller is the
+ * real source of truth. Same-chain swaps DO complete on broadcast.
+ */
+export function isCrossChainSwap(quote: QuoteResponse): boolean {
+  const route = quote.routes?.[0]?.action
+  const from = route?.fromToken?.chainId
+  const to = route?.toToken?.chainId
+  if (from === undefined || to === undefined) return false
+  return String(from) !== String(to)
+}
diff --git a/src/lib/supabase.ts b/src/lib/supabase.ts
index 9f907d8..365cb4d 100644
--- a/src/lib/supabase.ts
+++ b/src/lib/supabase.ts
@@ -1,14 +1,6 @@
-import { createBrowserClient } from '@supabase/ssr'
 import { createClient as createSupabaseClient, SupabaseClient } from '@supabase/supabase-js'
 import { Database } from '@/types/database.types'
 
-// Client-side (Browser)
-export const createClient = () =>
-  createBrowserClient<Database>(
-    process.env.NEXT_PUBLIC_SUPABASE_URL!,
-    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
-  )
-
 // Server-side (API Routes, Services, Background Jobs)
 export const createServerClient = () =>
   createSupabaseClient(
diff --git a/src/lib/token-filter.ts b/src/lib/token-filter.ts
index a004c88..dfb8a7b 100644
--- a/src/lib/token-filter.ts
+++ b/src/lib/token-filter.ts
@@ -127,3 +127,87 @@ export function filterSpamTokens(
     return !isSpamToken(token, count, canonical)
   })
 }
+
+/**
+ * Known bridged/variant stablecoin symbols folded into their canonical base
+ * for display. Only stablecoins — never fold arbitrary tokens by symbol.
+ */
+const SYMBOL_VARIANT_MAP: Record<string, string> = {
+  'USDC.E': 'USDC',
+  USDBC: 'USDC',
+  FUSDT: 'USDT',
+}
+
+/**
+ * Normalize a token symbol to its display family key (case-insensitive,
+ * folds known bridged variants like USDC.e → USDC).
+ */
+export function normalizeSymbolKey(symbol: string): string {
+  const upper = (symbol || '').toUpperCase()
+  return SYMBOL_VARIANT_MAP[upper] || upper
+}
+
+/**
+ * Collapse same-symbol tokens into a single canonical row per symbol family.
+ *
+ * Fixes the "2-3 USDC / multiple SOL on one chain" problem: providers return the
+ * same logical token at different addresses (native USDC vs USDC.e vs another
+ * provider's USDC), and without this they each render as a separate selectable row.
+ *
+ * Within each family the winner is scored by: native > exact base-symbol match >
+ * canonical address > provider count > has-logo. A family with only a bridged
+ * variant (e.g. USDC.e but no USDC) keeps that variant — never drops a whole family.
+ *
+ * @param tokens - Tokens for a single chain (already spam-filtered)
+ * @param chainKey - Chain key for canonical address lookup
+ * @param providerCounts - Optional map of lowercase address → provider count;
+ *   falls back to providerIds._count on each token.
+ */
+export function collapseTokensBySymbol(
+  tokens: UnifiedToken[],
+  chainKey?: string,
+  providerCounts?: Map<string, number>,
+): UnifiedToken[] {
+  const canonical = chainKey ? buildCanonicalAddresses(chainKey) : new Set<string>()
+  const groups = new Map<string, UnifiedToken[]>()
+
+  for (const token of tokens) {
+    const key = normalizeSymbolKey(token.symbol)
+    const group = groups.get(key)
+    if (group) group.push(token)
+    else groups.set(key, [token])
+  }
+
+  const countOf = (t: UnifiedToken): number => {
+    if (providerCounts) {
+      const c = providerCounts.get(t.address.toLowerCase())
+      if (c) return c
+    }
+    const ids = t.providerIds as Record<string, unknown> | undefined
+    if (ids && typeof ids._count === 'number') return ids._count as number
+    return 1
+  }
+
+  const result: UnifiedToken[] = []
+  for (const group of groups.values()) {
+    if (group.length === 1) {
+      result.push(group[0])
+      continue
+    }
+    const familyKey = normalizeSymbolKey(group[0].symbol)
+    const score = (t: UnifiedToken): number => {
+      let s = 0
+      if (t.isNative) s += 1000
+      // Base symbol (USDC) beats bridged variant (USDC.e) within the same family
+      if ((t.symbol || '').toUpperCase() === familyKey) s += 100
+      if (canonical.has(t.address.toLowerCase())) s += 50
+      s += Math.min(countOf(t), 9) * 2
+      if (t.logoUrl) s += 1
+      return s
+    }
+    const winner = group.reduce((best, t) => (score(t) > score(best) ? t : best), group[0])
+    result.push(winner)
+  }
+
+  return result
+}
diff --git a/src/lib/validations/payment-link.ts b/src/lib/validations/payment-link.ts
index 8b962c0..f0c7cf4 100644
--- a/src/lib/validations/payment-link.ts
+++ b/src/lib/validations/payment-link.ts
@@ -25,4 +25,3 @@ export const updatePaymentLinkSchema = createPaymentLinkSchema.partial().extend(
 })
 
 export type CreatePaymentLinkInput = z.infer<typeof createPaymentLinkSchema>
-export type UpdatePaymentLinkInput = z.infer<typeof updatePaymentLinkSchema>
diff --git a/src/services/__tests__/cctp.test.ts b/src/services/__tests__/cctp.test.ts
new file mode 100644
index 0000000..90850a3
--- /dev/null
+++ b/src/services/__tests__/cctp.test.ts
@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { cctpProvider } from '@/services/providers/cctp'
+import type { QuoteRequest } from '@/types/provider'
+
+/**
+ * CCTP Phase 5 tests (C1).
+ *
+ * Grounded in REAL captured Iris fee responses (provider-logs/quote-cctp-*.json):
+ *   Eth-USDC -> Arb-USDC, 10 USDC in: toAmount 9999000 (fee 1000 raw = $0.001)
+ *   Arb-USDC -> Base-USDC, 10 USDC in: toAmount 9998700 (fee 1300 raw = $0.0013)
+ * The fee is DEDUCTED from output (output < input), so it is a BRIDGE fee that is
+ * included, NOT an on-top GAS fee. And the Iris fee fetch must fail CLOSED.
+ */
+
+const ARB_TO_BASE: QuoteRequest = {
+  fromChain: 42161,
+  toChain: 8453,
+  fromToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+  toToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+  fromAmount: '10000000',
+  fromAddress: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
+  fromTokenDecimals: 6,
+}
+
+function feeResponse(body: unknown, ok = true, status = 200) {
+  return {
+    ok,
+    status,
+    json: async () => body,
+    text: async () => JSON.stringify(body),
+  } as unknown as Response
+}
+
+let fetchMock: ReturnType<typeof vi.fn>
+
+beforeEach(() => {
+  fetchMock = vi.fn()
+  vi.stubGlobal('fetch', fetchMock)
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+describe('cctp getQuote — C1 (fee label + fail-closed + duration)', () => {
+  it('labels the deducted fee as BRIDGE and included (not on-top GAS)', async () => {
+    // Real Iris fee: minimumFee in 1/100 bps. 1 -> 0.0001 fraction of 10000000 = 1000 raw.
+    fetchMock.mockResolvedValueOnce(feeResponse([{ minimumFee: 1 }]))
+    const [quote] = await cctpProvider.getQuote(ARB_TO_BASE)
+    expect(quote).toBeDefined()
+    const fee = quote.routes[0].estimate.feeCosts?.[0]
+    expect(fee?.type).toBe('BRIDGE')
+    expect(fee?.included).toBe(true)
+    // Output is reduced by the fee (deducted, not on-top).
+    expect(Number(quote.toAmount)).toBeLessThan(Number(quote.fromAmount))
+  })
+
+  it('uses a realistic CCTP settlement duration (>= 900s), not ~20s', async () => {
+    fetchMock.mockResolvedValueOnce(feeResponse([{ minimumFee: 1 }]))
+    const [quote] = await cctpProvider.getQuote(ARB_TO_BASE)
+    expect(quote.estimatedDuration).toBeGreaterThanOrEqual(900)
+  })
+
+  it('fails CLOSED (no quote) when the Iris fee endpoint is down', async () => {
+    fetchMock.mockResolvedValueOnce(feeResponse({ error: 'down' }, false, 503))
+    const quotes = await cctpProvider.getQuote(ARB_TO_BASE)
+    // A fee=0 quote could falsely win ranking — must not be returned.
+    expect(quotes).toEqual([])
+  })
+
+  it('fails CLOSED (no quote) when the Iris fetch throws', async () => {
+    fetchMock.mockRejectedValueOnce(new Error('network'))
+    const quotes = await cctpProvider.getQuote(ARB_TO_BASE)
+    expect(quotes).toEqual([])
+  })
+
+  it('fails CLOSED when Iris returns an empty fee array', async () => {
+    fetchMock.mockResolvedValueOnce(feeResponse([]))
+    const quotes = await cctpProvider.getQuote(ARB_TO_BASE)
+    expect(quotes).toEqual([])
+  })
+})
diff --git a/src/services/__tests__/quote-aggregator-validation.test.ts b/src/services/__tests__/quote-aggregator-validation.test.ts
new file mode 100644
index 0000000..21f7c20
--- /dev/null
+++ b/src/services/__tests__/quote-aggregator-validation.test.ts
@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest'
+import { QuoteAggregator } from '@/services/quote-aggregator'
+
+/**
+ * These exercise the central request validation that runs BEFORE provider
+ * fan-out, so they make no network calls — an unsupported chain or a bad
+ * address returns early.
+ */
+describe('QuoteAggregator.getQuotes — request validation (no fan-out)', () => {
+  it('returns unsupported with a reason for an exotic source chain', async () => {
+    const result = await QuoteAggregator.getQuotes({
+      fromChain: 'stellar',
+      toChain: 8453,
+      fromToken: 'native',
+      toToken: '0xUSDC',
+      fromAmount: '10',
+      fromAddress: '',
+    })
+
+    expect(result.unsupported).toBe(true)
+    expect(result.reason).toMatch(/not supported/i)
+    expect(result.quotes).toEqual([])
+    expect(result.bestQuote).toBeNull()
+    expect(result.providerStats.succeeded).toEqual([])
+    expect(result.providerStats.failed).toEqual([])
+  })
+
+  it('returns unsupported for an exotic destination chain', async () => {
+    const result = await QuoteAggregator.getQuotes({
+      fromChain: 1,
+      toChain: 'xrp',
+      fromToken: '0xToken',
+      toToken: 'native',
+      fromAmount: '10',
+      fromAddress: '',
+    })
+
+    expect(result.unsupported).toBe(true)
+    expect(result.reason).toMatch(/not supported/i)
+    expect(result.quotes).toEqual([])
+  })
+
+  it('returns an address-mismatch reason (not unsupported) for a bad fromAddress', async () => {
+    const result = await QuoteAggregator.getQuotes({
+      fromChain: 1,
+      toChain: 1,
+      fromToken: '0xToken',
+      toToken: '0xOther',
+      fromAmount: '1000000',
+      fromAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+    })
+
+    expect(result.unsupported).toBeFalsy()
+    expect(result.reason).toMatch(/source address/i)
+    expect(result.quotes).toEqual([])
+    expect(result.bestQuote).toBeNull()
+  })
+})
diff --git a/src/services/__tests__/ranking.test.ts b/src/services/__tests__/ranking.test.ts
new file mode 100644
index 0000000..48f6784
--- /dev/null
+++ b/src/services/__tests__/ranking.test.ts
@@ -0,0 +1,165 @@
+import { describe, it, expect } from 'vitest'
+import { rankQuotes, netOutput, consensusDecimals } from '../ranking'
+import type { QuoteResponse } from '@/types/provider'
+
+/**
+ * Minimal quote builder. Decimals are declared via top-level `toTokenDecimals`
+ * (preferred) falling back to routes[0].action.toToken.decimals.
+ */
+function q(over: Partial<QuoteResponse> & { provider: string; toAmount: string }): QuoteResponse {
+  return {
+    id: over.provider + '-' + over.toAmount,
+    fromAmount: '0',
+    toAmountMin: over.toAmount,
+    estimatedGas: '0',
+    estimatedDuration: 60,
+    routes: [],
+    ...over,
+  } as QuoteResponse
+}
+
+describe('consensusDecimals', () => {
+  it('returns the most common declared decimals across quotes', () => {
+    const quotes = [
+      q({ provider: 'a', toAmount: '1', toTokenDecimals: 6 }),
+      q({ provider: 'b', toAmount: '1', toTokenDecimals: 6 }),
+      q({ provider: 'c', toAmount: '1', toTokenDecimals: 18 }),
+    ]
+    expect(consensusDecimals(quotes)).toBe(6)
+  })
+})
+
+describe('netOutput', () => {
+  it('normalizes toAmount by the destination decimals', () => {
+    // 10_000_000 at 6 decimals = 10.0 human units
+    expect(netOutput(q({ provider: 'a', toAmount: '10000000', toTokenDecimals: 6 }), 6)).toBeCloseTo(10, 6)
+  })
+
+  it('converts on-top USD fee to destination-token units when toTokenPriceUSD is known', () => {
+    // Dest token worth $2000 (e.g. WETH). 1.0 token out, $20 on-top fee = 0.01 token.
+    const quote = q({
+      provider: 'a',
+      toAmount: '1000000000000000000', // 1.0 at 18 dec
+      toTokenDecimals: 18,
+      toTokenPriceUSD: 2000,
+      routes: [
+        {
+          type: 'swap', tool: 't',
+          action: {
+            fromToken: { address: '0x', chainId: 1, symbol: 'X', decimals: 18 },
+            toToken: { address: '0x', chainId: 1, symbol: 'WETH', decimals: 18 },
+            fromAmount: '0', toAmount: '1000000000000000000',
+          },
+          estimate: { feeCosts: [{ type: 'GAS', name: 'gas', amount: '0', amountUSD: '20', included: false }] },
+        },
+      ],
+    })
+    // 1.0 WETH - ($20 / $2000) = 1.0 - 0.01 = 0.99 (NOT 1.0 - 20 = -19)
+    expect(netOutput(quote, 18)).toBeCloseTo(0.99, 6)
+  })
+
+  it('subtracts on-top (included:false) fee costs in USD', () => {
+    const quote = q({
+      provider: 'a',
+      toAmount: '10000000',
+      toTokenDecimals: 6,
+      routes: [
+        {
+          type: 'swap',
+          tool: 't',
+          action: {
+            fromToken: { address: '0x', chainId: 1, symbol: 'X', decimals: 6 },
+            toToken: { address: '0x', chainId: 1, symbol: 'USDC', decimals: 6 },
+            fromAmount: '10000000',
+            toAmount: '10000000',
+          },
+          estimate: {
+            feeCosts: [
+              { type: 'PROTOCOL', name: 'on-top', amount: '0', amountUSD: '0.50', included: false },
+              { type: 'BRIDGE', name: 'deducted', amount: '0', amountUSD: '0.20', included: true },
+            ],
+          },
+        },
+      ],
+    })
+    // 10.0 - 0.50 (only the included:false fee) = 9.5
+    expect(netOutput(quote, 6)).toBeCloseTo(9.5, 6)
+  })
+})
+
+describe('rankQuotes', () => {
+  it('A1 (catastrophic): a quote that MISLABELS decimals as 18 with a huge raw toAmount cannot beat a correct 6-decimal quote', () => {
+    const good = q({ provider: 'lifi', toAmount: '10000000', toTokenDecimals: 6 }) // 10.0 USDC
+    const bad = q({ provider: 'evil', toAmount: '9000000000000000000', toTokenDecimals: 18 }) // declares 18 → 9.0
+    const ranked = rankQuotes([bad, good])
+    // Old BigInt(toAmount) logic ranked `bad` first (9e18 > 1e7). Correct logic: good wins (10.0 > 9.0).
+    expect(ranked[0].provider).toBe('lifi')
+  })
+
+  it('A1 (guard): a quote whose decimals disagree with the consensus is ranked below all trusted quotes', () => {
+    const trustedA = q({ provider: 'lifi', toAmount: '9986386', toTokenDecimals: 6 }) // 9.986
+    const trustedB = q({ provider: 'near-intents', toAmount: '9952218', toTokenDecimals: 6 }) // 9.952
+    const mislabeled = q({ provider: 'symbiosis', toAmount: '10010197', toTokenDecimals: 18 }) // claims 18 (really 6); untrusted
+    const ranked = rankQuotes([mislabeled, trustedA, trustedB])
+    // Symbiosis declares decimals that disagree with consensus(6) → untrusted → must NOT be best.
+    expect(ranked[0].provider).not.toBe('symbiosis')
+    expect(ranked[ranked.length - 1].provider).toBe('symbiosis')
+  })
+
+  it('A1 (majority-mislabel): when MOST providers mislabel decimals, the authoritative refDecimals still wins', () => {
+    // Real dest token is 6-dec USDC. Two providers mislabel as 18, one correct at 6.
+    // Majority-vote consensus would pick 18 and demote the correct quote — the bug.
+    const correct = q({ provider: 'lifi', toAmount: '10000000', toTokenDecimals: 6 }) // 10.0 USDC
+    const wrong1 = q({ provider: 'symbiosis', toAmount: '9000000000000000000', toTokenDecimals: 18 }) // claims 18 → 9.0
+    const wrong2 = q({ provider: 'rubic', toAmount: '9500000000000000000', toTokenDecimals: 18 }) // claims 18 → 9.5
+    // refDecimals=6 is the authoritative destination-token decimals from the request.
+    const ranked = rankQuotes([wrong1, wrong2, correct], 6)
+    expect(ranked[0].provider).toBe('lifi') // correct 6-dec quote wins despite being the minority
+  })
+
+  it('refDecimals: quotes matching the authoritative decimals are trusted; mismatches demoted', () => {
+    const good = q({ provider: 'lifi', toAmount: '10000000', toTokenDecimals: 6 })
+    const bad = q({ provider: 'symbiosis', toAmount: '99999999999999999999', toTokenDecimals: 18 })
+    const ranked = rankQuotes([bad, good], 6)
+    expect(ranked[0].provider).toBe('lifi')
+    expect(ranked[ranked.length - 1].provider).toBe('symbiosis')
+  })
+
+  it('A2 (fees): a lower-gross quote with no on-top fee beats a higher-gross quote with a large on-top fee', () => {
+    const grossHighFee = q({
+      provider: 'rubic',
+      toAmount: '10000000', // 10.0 gross
+      toTokenDecimals: 6,
+      routes: [
+        {
+          type: 'swap', tool: 't',
+          action: {
+            fromToken: { address: '0x', chainId: 1, symbol: 'X', decimals: 6 },
+            toToken: { address: '0x', chainId: 1, symbol: 'USDC', decimals: 6 },
+            fromAmount: '0', toAmount: '10000000',
+          },
+          estimate: { feeCosts: [{ type: 'PROTOCOL', name: 'fee', amount: '0', amountUSD: '0.65', included: false }] },
+        },
+      ],
+    }) // net 9.35
+    const lowerNoFee = q({ provider: 'lifi', toAmount: '9900000', toTokenDecimals: 6 }) // net 9.9
+    const ranked = rankQuotes([grossHighFee, lowerNoFee])
+    expect(ranked[0].provider).toBe('lifi')
+  })
+
+  it('no regression: same decimals, no fees → higher output wins', () => {
+    const ranked = rankQuotes([
+      q({ provider: 'a', toAmount: '9000000', toTokenDecimals: 6 }),
+      q({ provider: 'b', toAmount: '9500000', toTokenDecimals: 6 }),
+    ])
+    expect(ranked[0].provider).toBe('b')
+  })
+
+  it('A3 (tie-break reachable): near-equal net outputs are broken by reliability', () => {
+    // Same net output, different reliability (lifi 95 > rubic 85)
+    const r = q({ provider: 'rubic', toAmount: '10000000', toTokenDecimals: 6, estimatedDuration: 60 })
+    const l = q({ provider: 'lifi', toAmount: '10000000', toTokenDecimals: 6, estimatedDuration: 60 })
+    const ranked = rankQuotes([r, l])
+    expect(ranked[0].provider).toBe('lifi')
+  })
+})
diff --git a/src/services/__tests__/rubic.test.ts b/src/services/__tests__/rubic.test.ts
new file mode 100644
index 0000000..7154694
--- /dev/null
+++ b/src/services/__tests__/rubic.test.ts
@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { rubicProvider } from '../providers/rubic'
+import type { QuoteRequest } from '@/types/provider'
+
+const EVM_REQUEST: QuoteRequest = {
+  fromChain: 1,
+  toChain: 8453,
+  fromToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+  toToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+  fromAmount: '1000000',
+  fromAddress: '0x1111111111111111111111111111111111111111',
+  toAddress: '0x2222222222222222222222222222222222222222',
+  fromTokenDecimals: 6,
+}
+
+function jsonResponse(body: unknown, ok = true, status = 200): Response {
+  return {
+    ok,
+    status,
+    json: async () => body,
+    text: async () => JSON.stringify(body),
+  } as unknown as Response
+}
+
+function routeBy(url: string, handlers: Record<string, () => Response>): Response {
+  for (const key of Object.keys(handlers)) {
+    if (url.includes(key)) return handlers[key]()
+  }
+  throw new Error(`Unhandled fetch URL in test: ${url}`)
+}
+
+const QUOTE_BODY = {
+  id: 'rubic-quote-1',
+  type: 'across',
+  estimate: { destinationTokenAmount: '0.99', destinationTokenMinAmount: '0.98', estimatedTime: 120 },
+  tokens: { from: { symbol: 'USDC', decimals: 6 }, to: { symbol: 'USDC', decimals: 6 } },
+}
+
+describe('RubicProvider.getQuote — null transactionRequest hygiene', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('excludes an EVM quote when the swap call yields no transactionRequest', async () => {
+    vi.spyOn(global, 'fetch').mockImplementation(async (input: any) => {
+      const url = String(input)
+      return routeBy(url, {
+        '/info/chains': () => jsonResponse({ status: 'fail' }, false, 500),
+        '/routes/quoteBest': () => jsonResponse(QUOTE_BODY),
+        // swap fails -> transactionRequest stays null
+        '/routes/swap': () =>
+          jsonResponse({ error: { code: 3003, reason: 'not enough balance' } }, false, 400),
+      })
+    })
+
+    const quotes = await rubicProvider.getQuote(EVM_REQUEST)
+    expect(quotes.every((q) => q.transactionRequest != null)).toBe(true)
+    expect(quotes.length).toBe(0)
+  })
+
+  it('keeps an EVM quote when the swap call returns a transactionRequest', async () => {
+    vi.spyOn(global, 'fetch').mockImplementation(async (input: any) => {
+      const url = String(input)
+      return routeBy(url, {
+        '/info/chains': () => jsonResponse({ status: 'fail' }, false, 500),
+        '/routes/quoteBest': () => jsonResponse(QUOTE_BODY),
+        '/routes/swap': () =>
+          jsonResponse({
+            transaction: {
+              to: '0x3333333333333333333333333333333333333333',
+              data: '0xabcdef',
+              value: '0',
+            },
+          }),
+      })
+    })
+
+    const quotes = await rubicProvider.getQuote(EVM_REQUEST)
+    expect(quotes.length).toBe(1)
+    expect(quotes[0].transactionRequest).toBeTruthy()
+    expect((quotes[0].transactionRequest as { to?: string }).to).toBe(
+      '0x3333333333333333333333333333333333333333'
+    )
+  })
+
+  it('returns a deposit-trade quote for non-EVM source (Solana)', async () => {
+    const captured: { swapRawBody: string | null } = { swapRawBody: null }
+
+    vi.spyOn(global, 'fetch').mockImplementation(async (input: any, init: any) => {
+      const url = String(input)
+      if (url.includes('/info/chains')) {
+        return jsonResponse([
+          { id: 'solana', name: 'SOLANA' },
+          { id: 8453, name: 'BASE' },
+        ])
+      }
+      if (url.includes('/routes/quoteDepositTrades')) {
+        return jsonResponse({
+          routes: [
+            {
+              id: null,
+              estimate: {
+                destinationTokenAmount: '4.99',
+                destinationTokenMinAmount: '4.93',
+              },
+              tokens: {
+                from: { symbol: 'USDC', decimals: 6 },
+                to: { symbol: 'USDC', decimals: 6 },
+              },
+              type: null,
+              fees: {},
+            },
+          ],
+        })
+      }
+      if (url.includes('/routes/swapDepositTrade')) {
+        captured.swapRawBody = init?.body ? (init.body as string) : null
+        return jsonResponse({
+          transaction: { depositAddress: 'DEP_ADDR', exchangeId: 'EX1' },
+        })
+      }
+      throw new Error(`Unhandled fetch URL in test: ${url}`)
+    })
+
+    const quotes = await rubicProvider.getQuote({
+      fromChain: 'solana',
+      toChain: 8453,
+      fromToken: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+      toToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+      fromAmount: '5000000',
+      fromAddress: '5tzFkiKscXHK5ZXCGbXZxdw7gTjjD1mBwuoFbhUvuAi9',
+      toAddress: '0x2222222222222222222222222222222222222222',
+      fromTokenDecimals: 6,
+    })
+
+    const swapBody = captured.swapRawBody
+      ? (JSON.parse(captured.swapRawBody) as { refundAddress?: string })
+      : null
+
+    expect(quotes).toHaveLength(1)
+    expect(quotes[0].metadata?.depositAddress).toBe('DEP_ADDR')
+    expect(quotes[0].metadata?.isDepositTrade).toBe(true)
+    expect(swapBody?.refundAddress).toBe('5tzFkiKscXHK5ZXCGbXZxdw7gTjjD1mBwuoFbhUvuAi9')
+  })
+})
diff --git a/src/services/__tests__/symbiosis.test.ts b/src/services/__tests__/symbiosis.test.ts
new file mode 100644
index 0000000..b7fe904
--- /dev/null
+++ b/src/services/__tests__/symbiosis.test.ts
@@ -0,0 +1,147 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { symbiosisProvider, computeSymbiosisFeeUSD } from '@/services/providers/symbiosis'
+import { ChainTokenService } from '@/services/chain-token-service'
+
+/**
+ * Symbiosis Phase 5 tests (S2 / decimals / S3).
+ *
+ * Grounded in a REAL /v1/swap response (Arb-USDC -> Base-USDC, 10 USDC):
+ *   tokenAmountOut: { amount:"9492719", decimals:18 (echoed hint!), priceUsd:0.999576 }
+ *   fee: { amount:"250000", decimals:6, priceUsd:0.9996597 }  // ~$0.25
+ * The token is 6-decimal USDC; decimals:18 is the echoed request hint, NOT real.
+ */
+
+type FetchResponse = {
+  ok: boolean
+  status?: number
+  json: () => Promise<unknown>
+  text: () => Promise<string>
+}
+
+function mockResponse(body: unknown, ok = true, status = 200): FetchResponse {
+  return {
+    ok,
+    status,
+    json: async () => body,
+    text: async () => (typeof body === 'string' ? body : JSON.stringify(body)),
+  }
+}
+
+let fetchMock: ReturnType<typeof vi.fn>
+
+beforeEach(() => {
+  fetchMock = vi.fn()
+  vi.stubGlobal('fetch', fetchMock)
+  // Default: registry resolves USDC-Base to 6 decimals.
+  vi.spyOn(ChainTokenService, 'getTokens').mockResolvedValue([
+    {
+      address: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+      chainId: 8453,
+      symbol: 'USDC',
+      decimals: 6,
+    },
+  ] as never)
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+const REAL_SWAP = {
+  id: 'sym-real-1',
+  tokenAmountIn: {
+    symbol: 'USDC',
+    address: '0xaf88',
+    amount: '10000000',
+    chainId: 42161,
+    decimals: 6,
+  },
+  tokenAmountOut: {
+    symbol: 'tokenOut',
+    address: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+    amount: '9492719',
+    chainId: 8453,
+    decimals: 18, // echoed hint — NOT the real token decimals
+    priceUsd: 0.999576,
+  },
+  priceImpact: 0.28,
+  fee: {
+    symbol: 'USDbC',
+    address: '0xd9aAEc86',
+    amount: '250000',
+    chainId: 8453,
+    decimals: 6,
+    priceUsd: 0.9996597,
+  },
+  estimatedTime: 15,
+  tx: { to: '0xrouter', data: '0xdead', value: '0', chainId: 8453 },
+}
+
+const ARB_TO_BASE = {
+  fromChain: 42161,
+  toChain: 8453,
+  fromToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+  toToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+  fromAmount: '10000000',
+  fromAddress: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
+  fromTokenDecimals: 6,
+}
+
+describe('computeSymbiosisFeeUSD', () => {
+  it('computes real USD fee from {amount, decimals, priceUsd}', () => {
+    // 250000 / 10^6 * 0.9996597 = 0.2499...  -> "0.25"
+    expect(computeSymbiosisFeeUSD({ amount: '250000', decimals: 6, priceUsd: 0.9996597 })).toBe(
+      '0.25',
+    )
+  })
+  it('defaults priceUsd to 1 when missing', () => {
+    expect(computeSymbiosisFeeUSD({ amount: '250000', decimals: 6 })).toBe('0.25')
+  })
+  it('returns undefined when fee is absent or malformed', () => {
+    expect(computeSymbiosisFeeUSD(undefined)).toBeUndefined()
+    expect(computeSymbiosisFeeUSD({})).toBeUndefined()
+    expect(computeSymbiosisFeeUSD({ amount: '250000' })).toBeUndefined()
+  })
+})
+
+describe('symbiosis getQuote — S2 (real fee) + decimals', () => {
+  it('reports the REAL fee (~$0.25), NOT the implied-fee heuristic, and not in estimatedGas', async () => {
+    fetchMock.mockResolvedValueOnce(mockResponse(REAL_SWAP))
+    const [quote] = await symbiosisProvider.getQuote(ARB_TO_BASE as never)
+    expect(quote).toBeDefined()
+    // Real fee ~0.25 (NOT the implied heuristic which would be |10 - 9.49| = 0.51 at 6 dec).
+    expect(quote.fees?.totalFeeUSD).toBe('0.25')
+    expect(quote.fees?.bridgeFee).toBe('0.25')
+    // estimatedGas must NOT carry the fee anymore (no gas in response -> '0').
+    expect(quote.estimatedGas).toBe('0')
+    // feeCosts amountUSD reflects the real fee.
+    const feeCost = quote.routes[0].estimate.feeCosts?.[0]
+    expect(feeCost?.amountUSD).toBe('0.25')
+  })
+
+  it('resolves REAL dest decimals (6) from request.toTokenDecimals, ignoring the echoed 18', async () => {
+    fetchMock.mockResolvedValueOnce(mockResponse(REAL_SWAP))
+    const [quote] = await symbiosisProvider.getQuote(ARB_TO_BASE as never)
+    expect(quote.toTokenDecimals).toBe(6)
+    expect(quote.routes[0].action.toToken.decimals).toBe(6)
+    // CRITICAL: the raw amount itself is unchanged (only the decimals label is corrected).
+    expect(quote.toAmount).toBe('9492719')
+  })
+
+  it('falls back to the token registry for decimals when request omits toTokenDecimals', async () => {
+    fetchMock.mockResolvedValueOnce(mockResponse(REAL_SWAP))
+    const { fromTokenDecimals, ...noDecimals } = ARB_TO_BASE
+    void fromTokenDecimals
+    const [quote] = await symbiosisProvider.getQuote({ ...noDecimals } as never)
+    // Registry mock returns USDC-Base at 6 decimals.
+    expect(quote.toTokenDecimals).toBe(6)
+  })
+
+  it('falls back to implied-fee heuristic only when data.fee is absent', async () => {
+    const noFee = { ...REAL_SWAP, fee: undefined }
+    fetchMock.mockResolvedValueOnce(mockResponse(noFee))
+    const [quote] = await symbiosisProvider.getQuote(ARB_TO_BASE as never)
+    // input 10 USDC, output 9.492719 USDC (in=6dec, out resolved to 6dec) -> implied ~0.51
+    expect(parseFloat(quote.fees?.totalFeeUSD || '0')).toBeCloseTo(0.51, 2)
+  })
+})
diff --git a/src/services/chain-token-service.ts b/src/services/chain-token-service.ts
index 89c3fa7..f720716 100644
--- a/src/services/chain-token-service.ts
+++ b/src/services/chain-token-service.ts
@@ -4,7 +4,7 @@ import { OneClickService, OpenAPI } from '@defuse-protocol/one-click-sdk-typescr
 import { SYMBIOSIS_CONFIG } from '@/services/providers/symbiosis-data'
 import { CHAINS } from '@/lib/chains'
 import { TOKENS } from '@/lib/tokens'
-import { filterSpamTokens } from '@/lib/token-filter'
+import { filterSpamTokens, collapseTokensBySymbol } from '@/lib/token-filter'
 import {
   UnifiedChain,
   UnifiedToken,
@@ -811,7 +811,9 @@ function mergeTokens(tokenSets: UnifiedToken[][], chainKey?: string): UnifiedTok
     addressCounts,
     chainKey,
   )
-  const result = filtered
+  // Collapse same-symbol variants (USDC/USDC.e, multiple native SOL) into one
+  // canonical row per symbol so the UI shows a single selectable entry.
+  const result = collapseTokensBySymbol(filtered, chainKey, addressCounts)
   const canonical = chainKey ? buildCanonicalAddresses(chainKey) : new Set<string>()
 
   // Sort: native first, then canonical stablecoins, then multi-provider stablecoins,
diff --git a/src/services/providers/cctp.ts b/src/services/providers/cctp.ts
index 6d27d1d..6d1269d 100644
--- a/src/services/providers/cctp.ts
+++ b/src/services/providers/cctp.ts
@@ -1,4 +1,12 @@
-import { IProvider, QuoteRequest, QuoteResponse, StatusRequest, StatusResponse, TransactionStatus, FeeCost } from '@/types/provider'
+import {
+  IProvider,
+  QuoteRequest,
+  QuoteResponse,
+  StatusRequest,
+  StatusResponse,
+  TransactionStatus,
+  FeeCost,
+} from '@/types/provider'
 
 /**
  * CCTP Provider - Circle Cross-Chain Transfer Protocol
@@ -6,14 +14,14 @@ import { IProvider, QuoteRequest, QuoteResponse, StatusRequest, StatusResponse,
 
 // USDC contract addresses on supported chains
 const USDC_ADDRESSES: Record<number, string> = {
-  1: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',      // Ethereum
-  42161: '0xaf88d065e77c8cc2239327c5edb3a432268e5831',  // Arbitrum
-  8453: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',   // Base
-  137: '0x3c499c542cef5e3811e1192ce70d8cc03d5c3359',    // Polygon
-  10: '0x0b2c639c533813f4aa9d7837caf62653d097ff85',     // Optimism
-  43114: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',  // Avalanche
-  59144: '0x176211869ca2b568f2a7d4ee941e073a821ee1ff',  // Linea
-  146: '0x29219dd400f2bf60e5a23d13be72b486d4038894',    // Sonic
+  1: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', // Ethereum
+  42161: '0xaf88d065e77c8cc2239327c5edb3a432268e5831', // Arbitrum
+  8453: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913', // Base
+  137: '0x3c499c542cef5e3811e1192ce70d8cc03d5c3359', // Polygon
+  10: '0x0b2c639c533813f4aa9d7837caf62653d097ff85', // Optimism
+  43114: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e', // Avalanche
+  59144: '0x176211869ca2b568f2a7d4ee941e073a821ee1ff', // Linea
+  146: '0x29219dd400f2bf60e5a23d13be72b486d4038894', // Sonic
 }
 
 // Bridge Kit chain name mapping
@@ -75,101 +83,114 @@ export class CCTPProvider implements IProvider {
         return []
       }
 
-      const fromNum = typeof request.fromChain === 'number' ? request.fromChain : Number(request.fromChain)
+      const fromNum =
+        typeof request.fromChain === 'number' ? request.fromChain : Number(request.fromChain)
       const toNum = typeof request.toChain === 'number' ? request.toChain : Number(request.toChain)
       if (isNaN(fromNum) || isNaN(toNum)) return []
 
       const sourceChain = CHAIN_TO_BRIDGE_KIT[fromNum]
       const destChain = CHAIN_TO_BRIDGE_KIT[toNum]
 
-      
       const domainIds: Record<number, number> = {
-        1: 0,      // Ethereum
-        43114: 1,  // Avalanche
-        10: 2,     // Optimism
-        42161: 3,  // Arbitrum
-        8453: 6,   // Base
-        137: 7,    // Polygon
+        1: 0, // Ethereum
+        43114: 1, // Avalanche
+        10: 2, // Optimism
+        42161: 3, // Arbitrum
+        8453: 6, // Base
+        137: 7, // Polygon
         59144: 11, // Linea
-        146: 14,   // Sonic
+        146: 14, // Sonic
       }
 
       const sourceDomain = domainIds[fromNum]
       const destDomain = domainIds[toNum]
 
-      let feePercentage = 0
+      // Fail CLOSED: if the real Iris fee can't be resolved we return no quote.
+      // Returning a fee=0 (1:1) quote would falsely beat every real provider in
+      // ranking and over-promise the output to the user.
+      let feePercentage: number | null = null
       try {
         const feeResponse = await fetch(
-          `${IRIS_API}/v2/burn/USDC/fees/${sourceDomain}/${destDomain}`
+          `${IRIS_API}/v2/burn/USDC/fees/${sourceDomain}/${destDomain}`,
         )
         if (feeResponse.ok) {
           const feeData = await feeResponse.json()
-          if (feeData && feeData.length > 0) {
+          if (feeData && feeData.length > 0 && typeof feeData[0].minimumFee === 'number') {
             feePercentage = feeData[0].minimumFee / 10000
           }
         }
       } catch (e) {
         console.warn('CCTP: Could not fetch fee estimate:', e)
       }
+      if (feePercentage === null) {
+        console.warn('CCTP: Iris fee unavailable, dropping quote (fail closed)')
+        return []
+      }
 
       const inputAmount = BigInt(request.fromAmount)
       const feeAmount = BigInt(Math.floor(Number(inputAmount) * feePercentage))
       const outputAmount = inputAmount - feeAmount
 
-      // Fast Transfer: 20s, Standard: 900s (15 min)
-      const estimatedDuration = 20
-
-      return [{
-        provider: 'cctp',
-        id: `cctp-${Date.now()}-${Math.random().toString(36).substring(7)}`,
-        fromAmount: request.fromAmount,
-        toAmount: outputAmount.toString(),
-        toAmountMin: outputAmount.toString(),
-        estimatedGas: '0',
-        estimatedDuration,
-        bridgeFee: feeAmount.toString(),
-        bridgeFeeUSD: (Number(feeAmount) / 1e6).toFixed(2),
-        transactionRequest: null,
-        routes: [{
-          type: 'bridge' as const,
-          tool: 'cctp',
-          action: {
-            fromToken: {
-              address: request.fromToken,
-              chainId: request.fromChain,
-              symbol: 'USDC',
-              decimals: 6
-            },
-            toToken: {
-              address: request.toToken,
-              chainId: request.toChain,
-              symbol: 'USDC',
-              decimals: 6
+      // CCTP standard settlement is ~15-20 min (attestation + mint), not seconds.
+      const estimatedDuration = 1200
+
+      return [
+        {
+          provider: 'cctp',
+          id: `cctp-${Date.now()}-${Math.random().toString(36).substring(7)}`,
+          fromAmount: request.fromAmount,
+          toAmount: outputAmount.toString(),
+          toAmountMin: outputAmount.toString(),
+          toTokenDecimals: 6, // CCTP only ever bridges USDC (6 decimals on all supported chains)
+          estimatedGas: '0',
+          estimatedDuration,
+          bridgeFee: feeAmount.toString(),
+          bridgeFeeUSD: (Number(feeAmount) / 1e6).toFixed(2),
+          transactionRequest: null,
+          routes: [
+            {
+              type: 'bridge' as const,
+              tool: 'cctp',
+              action: {
+                fromToken: {
+                  address: request.fromToken,
+                  chainId: request.fromChain,
+                  symbol: 'USDC',
+                  decimals: 6,
+                },
+                toToken: {
+                  address: request.toToken,
+                  chainId: request.toChain,
+                  symbol: 'USDC',
+                  decimals: 6,
+                },
+                fromAmount: request.fromAmount,
+                toAmount: outputAmount.toString(),
+              },
+              estimate: {
+                executionDuration: estimatedDuration,
+                feeCosts: [
+                  {
+                    type: 'BRIDGE',
+                    name: 'CCTP Bridge Fee',
+                    description: 'Circle fee deducted from the bridged amount',
+                    amount: feeAmount.toString(),
+                    amountUSD: (Number(feeAmount) / 1e6).toFixed(2),
+                    included: true,
+                  },
+                ],
+              },
             },
-            fromAmount: request.fromAmount,
-            toAmount: outputAmount.toString()
+          ],
+          metadata: {
+            sourceChain,
+            destChain,
+            sourceDomain,
+            destDomain,
+            fastTransfer: true,
           },
-          estimate: {
-            executionDuration: estimatedDuration,
-            feeCosts: [{
-              type: 'GAS',
-              name: 'Network Gas',
-              description: 'Gas for Burn (Source) + Mint (Dest)',
-              amount: feeAmount.toString(),
-              amountUSD: (Number(feeAmount) / 1e6).toFixed(2),
-              included: false
-            }]
-          }
-        }],
-        metadata: {
-          sourceChain,
-          destChain,
-          sourceDomain,
-          destDomain,
-          fastTransfer: true
-        }
-      }]
-
+        },
+      ]
     } catch (error) {
       console.error('CCTP Quote Error:', error)
       return []
@@ -178,9 +199,7 @@ export class CCTPProvider implements IProvider {
 
   async getStatus(request: StatusRequest): Promise<StatusResponse> {
     try {
-      const response = await fetch(
-        `${IRIS_API}/v2/messages?transactionHash=${request.txHash}`
-      )
+      const response = await fetch(`${IRIS_API}/v2/messages?transactionHash=${request.txHash}`)
 
       if (!response.ok) {
         return { status: 'NOT_FOUND' }
@@ -226,9 +245,9 @@ export class CCTPProvider implements IProvider {
       return {
         status,
         subStatus,
-        txLink: message.destinationTransactionHash 
+        txLink: message.destinationTransactionHash
           ? `https://blockscan.com/tx/${message.destinationTransactionHash}`
-          : undefined
+          : undefined,
       }
     } catch (error) {
       console.error('CCTP Status Error:', error)
diff --git a/src/services/providers/lifi.ts b/src/services/providers/lifi.ts
index 37dd656..c876cfc 100644
--- a/src/services/providers/lifi.ts
+++ b/src/services/providers/lifi.ts
@@ -151,6 +151,9 @@ export class LifiProvider implements IProvider {
       fromAmount: route.fromAmount,
       toAmount: route.toAmount,
       toAmountMin: route.toAmountMin,
+      toTokenDecimals: route.toToken?.decimals,
+      toTokenPriceUSD: route.toToken?.priceUSD ? parseFloat(route.toToken.priceUSD) : undefined,
+      toAmountUSD: route.toAmountUSD,
       estimatedGas: route.gasCostUSD || '0',
       estimatedDuration: route.steps.reduce((acc, step) => acc + (step.estimate.executionDuration || 0), 0),
       transactionRequest: txData || route,
diff --git a/src/services/providers/near-intents.ts b/src/services/providers/near-intents.ts
index 502c435..6c6f19e 100644
--- a/src/services/providers/near-intents.ts
+++ b/src/services/providers/near-intents.ts
@@ -1,5 +1,6 @@
 import { IProvider, QuoteRequest, QuoteResponse, StatusRequest, StatusResponse, TransactionStatus, FeeCost } from '@/types/provider'
 import { OneClickService, QuoteRequest as DefuseQuoteRequest, OpenAPI, TokenResponse } from '@defuse-protocol/one-click-sdk-typescript'
+import { deriveChainFamily } from '@/lib/chain-family'
 
 OpenAPI.BASE = 'https://1click.chaindefuser.com'
 
@@ -284,8 +285,10 @@ export class NearIntentsProvider implements IProvider {
         fromAmount: request.fromAmount,
         toAmount: quote.amountOut,
         toAmountMin: quote.minAmountOut || quote.amountOut,
+        toTokenDecimals: toTokenMeta?.decimals,
+        toAmountUSD: quote.amountOutUsd?.toString(),
         estimatedGas: '0', // NEAR Intents handles gas internally
-        estimatedDuration: quote.timeEstimate || 120, 
+        estimatedDuration: quote.timeEstimate || 120,
         transactionRequest: quote.depositAddress ? { 
           depositAddress: quote.depositAddress,
           memo: quote.depositMemo 
@@ -297,9 +300,9 @@ export class NearIntentsProvider implements IProvider {
           deadline: quote.deadline,
           amountOutFormatted: quote.amountOutFormatted,
           amountOutUsd: quote.amountOutUsd,
-          chainType: String(request.fromChain) === 'solana' ? 'solana' as const
-                   : String(request.fromChain) === 'bitcoin' ? 'bitcoin' as const
-                   : 'evm' as const,
+          // Real family — XRP/TON/Stellar/Tron/Sui resolve to 'other' (not 'evm'),
+          // so the executor blocks them instead of misrouting to the EVM signer.
+          chainType: deriveChainFamily(request.fromChain),
           isDepositTrade: true,
           amountToSend: request.fromAmount,
         },
@@ -350,7 +353,7 @@ export class NearIntentsProvider implements IProvider {
   }
 
   async getStatus(request: StatusRequest): Promise<StatusResponse> {
-    const { depositAddress } = request
+    const { depositAddress, depositMemo } = request
 
     if (!depositAddress) {
       console.error('NearIntentsProvider: depositAddress missing for status check')
@@ -361,7 +364,8 @@ export class NearIntentsProvider implements IProvider {
     }
 
     try {
-      const response = await OneClickService.getExecutionStatus(depositAddress)
+      // Pass the memo — memo-required deposit chains need it for status lookup.
+      const response = await OneClickService.getExecutionStatus(depositAddress, depositMemo)
       
       let finalStatus: TransactionStatus = 'PENDING'
       const status = (response.status || '').toUpperCase()
diff --git a/src/services/providers/rango.ts b/src/services/providers/rango.ts
index b6a9f68..435dd82 100644
--- a/src/services/providers/rango.ts
+++ b/src/services/providers/rango.ts
@@ -183,6 +183,8 @@ export class RangoProvider implements IProvider {
       fromAmount: fromAmount, 
       toAmount: quote.route.outputAmount,
       toAmountMin: quote.route.outputAmountMin,
+      toTokenDecimals: quote.route.to?.decimals,
+      toTokenPriceUSD: quote.route.to?.usdPrice ?? undefined,
       estimatedGas: quote.route.feeUsd?.toString() || '0',
       estimatedDuration: estimatedTime,
       transactionRequest: null, 
diff --git a/src/services/providers/rubic.ts b/src/services/providers/rubic.ts
index 4100c85..fd007cb 100644
--- a/src/services/providers/rubic.ts
+++ b/src/services/providers/rubic.ts
@@ -137,34 +137,42 @@ export class RubicProvider implements IProvider {
       }
 
       const data = await response.json()
-      
+
+      // quoteDepositTrades wraps the route in { routes: [route] }; quoteBest
+      // returns it flat. Normalize to a single quote payload accessor.
+      const quote = isNonEvmSource ? (data.routes?.[0] ?? {}) : data
+
       console.log('=== RUBIC RAW RESPONSE ===')
-      console.log('destinationTokenAmount:', data.estimate?.destinationTokenAmount)
-      console.log('destinationTokenMinAmount:', data.estimate?.destinationTokenMinAmount)
-      console.log('type/providerType:', data.type, data.providerType)
-      console.log('tokens:', JSON.stringify(data.tokens, null, 2))
+      console.log('destinationTokenAmount:', quote.estimate?.destinationTokenAmount)
+      console.log('destinationTokenMinAmount:', quote.estimate?.destinationTokenMinAmount)
+      console.log('type/providerType:', quote.type, quote.providerType)
+      console.log('tokens:', JSON.stringify(quote.tokens, null, 2))
       console.log('===========================')
-      
-      if (!data.estimate || !data.estimate.destinationTokenAmount) {
+
+      if (!quote.estimate || !quote.estimate.destinationTokenAmount) {
         console.log('Rubic: No routes found in response')
         return []
       }
 
       // Extract underlying provider name from Rubic
-      const underlyingProvider = data.type || data.providerType || 'rubic'
-      const gasCostUSD = data.estimate?.gasFeeInfo?.usdValue || '0'
-      
+      const underlyingProvider = quote.type || quote.providerType || 'rubic'
+      const gasCostUSD = quote.estimate?.gasFeeInfo?.usdValue || '0'
+
       // IMPORTANT: Rubic returns human-readable amounts
-      const toDecimals = data.tokens?.to?.decimals || 6
-      const toAmountHuman = data.estimate.destinationTokenAmount
-      const toAmountMinHuman = data.estimate.destinationTokenMinAmount || toAmountHuman
-      
+      const toDecimals = quote.tokens?.to?.decimals || 6
+      const toAmountHuman = quote.estimate.destinationTokenAmount
+      const toAmountMinHuman = quote.estimate.destinationTokenMinAmount || toAmountHuman
+
       // Process EVM transaction data
       let transactionRequest = null
-      let approvalAddress = data.transaction?.approvalAddress
+      let approvalAddress = quote.transaction?.approvalAddress
       let insufficientBalance = false
 
-      if (data.id) {
+      // Deposit trades quote with id=null but still need the swap call to obtain
+      // a deposit address; gate on the presence of an estimate instead.
+      const shouldFetchTx = isNonEvmSource ? Boolean(quote.estimate) : Boolean(quote.id)
+
+      if (shouldFetchTx) {
         try {
           if (isNonEvmSource) {
             // Non-EVM
@@ -173,8 +181,9 @@ export class RubicProvider implements IProvider {
               headers: { 'Content-Type': 'application/json' },
               body: JSON.stringify({
                 ...commonParams,
-                id: data.id,
+                id: quote.id,
                 receiver: request.toAddress || request.fromAddress,
+                refundAddress: request.fromAddress,
               })
             })
 
@@ -183,7 +192,10 @@ export class RubicProvider implements IProvider {
               if (swapData.transaction?.depositAddress) {
                 transactionRequest = {
                   depositAddress: swapData.transaction.depositAddress,
-                  amountToSend: swapData.transaction.amountToSend,
+                  // Rubic returns amountToSend in HUMAN units; the executor does
+                  // BigInt(amountToSend) expecting RAW base units. The deposit
+                  // amount equals the source amount the user pays = request.fromAmount.
+                  amountToSend: request.fromAmount,
                   exchangeId: swapData.transaction.exchangeId,
                   type: chainType,
                 }
@@ -196,7 +208,7 @@ export class RubicProvider implements IProvider {
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                  ...commonParams,
-                 id: data.id
+                 id: quote.id
                })
             })
             
@@ -231,19 +243,33 @@ export class RubicProvider implements IProvider {
         }
       }
 
+      // Drop non-executable quotes: Rubic cannot be executed without tx data.
+      // EVM swaps need transactionRequest.to/data (from /routes/swap); deposit
+      // trades need a depositAddress (from /routes/swapDepositTrade). When the
+      // swap call fails (e.g. insufficient balance) these are absent, and the
+      // quote would be unexecutable yet could still poison ranking as "best".
+      const hasExecutableTx = isNonEvmSource
+        ? Boolean(transactionRequest?.depositAddress)
+        : Boolean(transactionRequest?.to && transactionRequest?.data)
+      if (!hasExecutableTx) {
+        console.log('Rubic: dropping quote with no executable transaction data')
+        return []
+      }
+
       // Calculate total fees
-      const protocolFeeUSD = data.fees?.gasTokenFees?.protocol?.fixedUsdAmount || 0
-      const providerFeeUSD = data.fees?.gasTokenFees?.provider?.fixedUsdAmount || 0
+      const protocolFeeUSD = quote.fees?.gasTokenFees?.protocol?.fixedUsdAmount || 0
+      const providerFeeUSD = quote.fees?.gasTokenFees?.provider?.fixedUsdAmount || 0
       const totalFeeUSD = (parseFloat(gasCostUSD) + protocolFeeUSD + providerFeeUSD).toFixed(4)
 
       return [{
         provider: 'rubic',
-        id: data.id || Math.random().toString(36).substring(7),
+        id: quote.id || Math.random().toString(36).substring(7),
         fromAmount: request.fromAmount,
         toAmount: this.toWei(toAmountHuman, toDecimals),
         toAmountMin: this.toWei(toAmountMinHuman, toDecimals),
+        toTokenDecimals: toDecimals,
         estimatedGas: gasCostUSD,
-        estimatedDuration: data.estimate.estimatedTime || 300,
+        estimatedDuration: quote.estimate.estimatedTime || 300,
         transactionRequest,
         fees: {
           totalFeeUSD,
@@ -263,61 +289,61 @@ export class RubicProvider implements IProvider {
         routes: [{
           type: 'bridge' as const,
           tool: underlyingProvider,
-          toolName: data.providerName || underlyingProvider,
+          toolName: quote.providerName || underlyingProvider,
           action: {
             fromToken: {
               address: request.fromToken,
               chainId: request.fromChain,
-              symbol: data.tokens?.from?.symbol || 'UNKNOWN',
-              decimals: data.tokens?.from?.decimals || 18
+              symbol: quote.tokens?.from?.symbol || 'UNKNOWN',
+              decimals: quote.tokens?.from?.decimals || 18
             },
             toToken: {
               address: request.toToken,
               chainId: request.toChain,
-              symbol: data.tokens?.to?.symbol || 'UNKNOWN',
-              decimals: data.tokens?.to?.decimals || 18
+              symbol: quote.tokens?.to?.symbol || 'UNKNOWN',
+              decimals: quote.tokens?.to?.decimals || 18
             },
             fromAmount: request.fromAmount,
-            toAmount: this.toWei(data.estimate.destinationTokenAmount, toDecimals)
+            toAmount: this.toWei(quote.estimate.destinationTokenAmount, toDecimals)
           },
           // TODO: Add support for platform fees
           estimate: {
             approvalAddress,
-            executionDuration: data.estimate.estimatedTime,
+            executionDuration: quote.estimate.estimatedTime,
             feeCosts: [
               // Gas Fees
-              ...(data.fees?.gasTokenFees?.gas?.totalUsdAmount ? [{
+              ...(quote.fees?.gasTokenFees?.gas?.totalUsdAmount ? [{
                 type: 'GAS' as const,
                 name: 'Network Gas',
                 description: 'Estimated gas fee for transaction',
-                amount: data.fees.gasTokenFees.gas.totalWeiAmount || '0',
-                amountUSD: data.fees.gasTokenFees.gas.totalUsdAmount.toString(),
+                amount: quote.fees.gasTokenFees.gas.totalWeiAmount || '0',
+                amountUSD: quote.fees.gasTokenFees.gas.totalUsdAmount.toString(),
                 included: false,
                 token: {
-                  address: data.fees.gasTokenFees.nativeToken?.address || '',
-                  chainId: data.fees.gasTokenFees.nativeToken?.blockchainId || request.fromChain,
-                  symbol: data.fees.gasTokenFees.nativeToken?.symbol || 'ETH',
-                  decimals: data.fees.gasTokenFees.nativeToken?.decimals || 18
+                  address: quote.fees.gasTokenFees.nativeToken?.address || '',
+                  chainId: quote.fees.gasTokenFees.nativeToken?.blockchainId || request.fromChain,
+                  symbol: quote.fees.gasTokenFees.nativeToken?.symbol || 'ETH',
+                  decimals: quote.fees.gasTokenFees.nativeToken?.decimals || 18
                 }
               }] : []),
 
               // Rubic Protocol Fee
-              ...(data.fees?.gasTokenFees?.protocol?.fixedUsdAmount ? [{
+              ...(quote.fees?.gasTokenFees?.protocol?.fixedUsdAmount ? [{
                 type: 'PROTOCOL' as const,
                 name: 'Rubic Protocol Fee',
                 description: 'Fixed fee charged by Rubic',
-                amount: data.fees.gasTokenFees.protocol.fixedWeiAmount || '0',
-                amountUSD: data.fees.gasTokenFees.protocol.fixedUsdAmount.toString(),
+                amount: quote.fees.gasTokenFees.protocol.fixedWeiAmount || '0',
+                amountUSD: quote.fees.gasTokenFees.protocol.fixedUsdAmount.toString(),
                 included: true
               }] : []),
 
               // Provider/Bridge Fee
-              ...(data.fees?.gasTokenFees?.provider?.fixedUsdAmount ? [{
+              ...(quote.fees?.gasTokenFees?.provider?.fixedUsdAmount ? [{
                 type: 'BRIDGE' as const,
                 name: 'Provider Fee',
                 description: 'Fee charged by the underlying bridge/provider',
-                amount: data.fees.gasTokenFees.provider.fixedWeiAmount || '0',
-                amountUSD: data.fees.gasTokenFees.provider.fixedUsdAmount.toString(),
+                amount: quote.fees.gasTokenFees.provider.fixedWeiAmount || '0',
+                amountUSD: quote.fees.gasTokenFees.provider.fixedUsdAmount.toString(),
                 included: true
               }] : [])
             ]
diff --git a/src/services/providers/symbiosis.ts b/src/services/providers/symbiosis.ts
index 232fbf3..5433083 100644
--- a/src/services/providers/symbiosis.ts
+++ b/src/services/providers/symbiosis.ts
@@ -1,10 +1,57 @@
-import { IProvider, QuoteRequest, QuoteResponse, StatusRequest, StatusResponse, TransactionStatus } from '@/types/provider'
+import {
+  IProvider,
+  QuoteRequest,
+  QuoteResponse,
+  StatusRequest,
+  StatusResponse,
+  TransactionStatus,
+} from '@/types/provider'
 import { SYMBIOSIS_GATEWAY_MAP, SYMBIOSIS_CHAIN_IDS } from './symbiosis-config'
 import { SYMBIOSIS_CONFIG } from './symbiosis-data'
+import { ChainTokenService } from '../chain-token-service'
+
+/**
+ * Resolve the REAL destination-token decimals. Symbiosis echoes back the `decimals`
+ * hint we send in `tokenOut` (we send 18), so `data.tokenAmountOut.decimals` is NOT
+ * authoritative for 6/8-decimal tokens like USDC/WBTC. Prefer the caller-supplied
+ * authoritative decimals, then the live token registry, then the API value.
+ */
+export async function resolveToTokenDecimals(
+  request: QuoteRequest,
+  toChain: number,
+  apiDecimals: number | undefined,
+): Promise<number | undefined> {
+  if (typeof request.toTokenDecimals === 'number') return request.toTokenDecimals
+  try {
+    const tokens = await ChainTokenService.getTokens(String(toChain))
+    const target = request.toToken.toLowerCase()
+    const match = tokens.find((t) => t.address.toLowerCase() === target)
+    if (match?.decimals !== undefined) return match.decimals
+  } catch {
+    // fall through to API value
+  }
+  return apiDecimals
+}
+
+/**
+ * Compute the REAL fee in USD. Symbiosis returns the fee as
+ * `{ amount, decimals, priceUsd }` (NOT `fee.usd`). Convert it to a human USD
+ * value. Returns undefined when `data.fee` is absent so callers can fall back.
+ */
+export function computeSymbiosisFeeUSD(fee: unknown): string | undefined {
+  if (!fee || typeof fee !== 'object') return undefined
+  const f = fee as { amount?: string | number; decimals?: number; priceUsd?: number }
+  if (f.amount === undefined || f.decimals === undefined) return undefined
+  const human = Number(f.amount) / Math.pow(10, f.decimals)
+  if (!isFinite(human)) return undefined
+  return (human * (f.priceUsd ?? 1)).toFixed(2)
+}
 
 const SYMBIOSIS_API_BASE = 'https://api.symbiosis.finance/crosschain/v1'
 const SYMBIOSIS_BTC_CHAIN_ID = 3652501241
-const SYMBIOSIS_BTC_FORWARDER_URL = SYMBIOSIS_CONFIG.btcConfigs?.[0]?.forwarderUrl || 'https://btc-forwarder.symbiosis.finance/bsc-v2/forwarder/api/v1'
+const SYMBIOSIS_BTC_FORWARDER_URL =
+  SYMBIOSIS_CONFIG.btcConfigs?.[0]?.forwarderUrl ||
+  'https://btc-forwarder.symbiosis.finance/bsc-v2/forwarder/api/v1'
 
 export class SymbiosisProvider implements IProvider {
   name = 'symbiosis'
@@ -12,15 +59,18 @@ export class SymbiosisProvider implements IProvider {
   async getQuote(request: QuoteRequest): Promise<QuoteResponse[]> {
     try {
       const resolveChainId = (chain: number | string): number => {
-        if (typeof chain === 'string' && chain.toLowerCase() === 'bitcoin') return SYMBIOSIS_BTC_CHAIN_ID
+        if (typeof chain === 'string' && chain.toLowerCase() === 'bitcoin')
+          return SYMBIOSIS_BTC_CHAIN_ID
         return typeof chain === 'number' ? chain : Number(chain)
       }
       const fromChainId = resolveChainId(request.fromChain)
       const toChainId = resolveChainId(request.toChain)
       if (isNaN(fromChainId) || isNaN(toChainId)) return []
-      
-      const isFromSupported = SYMBIOSIS_CHAIN_IDS.includes(fromChainId) || fromChainId === SYMBIOSIS_BTC_CHAIN_ID
-      const isToSupported = SYMBIOSIS_CHAIN_IDS.includes(toChainId) || toChainId === SYMBIOSIS_BTC_CHAIN_ID
+
+      const isFromSupported =
+        SYMBIOSIS_CHAIN_IDS.includes(fromChainId) || fromChainId === SYMBIOSIS_BTC_CHAIN_ID
+      const isToSupported =
+        SYMBIOSIS_CHAIN_IDS.includes(toChainId) || toChainId === SYMBIOSIS_BTC_CHAIN_ID
 
       if (!isFromSupported || !isToSupported) {
         return []
@@ -34,12 +84,14 @@ export class SymbiosisProvider implements IProvider {
           chainId: fromChainId,
           address: request.fromToken,
           amount: request.fromAmount,
-          decimals: 18 
+          // Real source-token decimals (hardcoding 18 mis-prices 6/8-dec tokens like USDC/WBTC)
+          decimals: request.fromTokenDecimals ?? 18,
         },
         tokenOut: {
           chainId: toChainId,
           address: request.toToken,
-          decimals: 18  
+          // Hint only — Symbiosis resolves real decimals from the address; response is authoritative
+          decimals: 18,
         },
         from: request.fromAddress,
         to: request.toAddress || request.fromAddress,
@@ -58,7 +110,7 @@ export class SymbiosisProvider implements IProvider {
       const response = await fetch(`${SYMBIOSIS_API_BASE}/swap`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(swapBody)
+        body: JSON.stringify(swapBody),
       })
 
       if (!response.ok) {
@@ -68,7 +120,7 @@ export class SymbiosisProvider implements IProvider {
       }
 
       const data = await response.json()
-      
+
       console.log('=== SYMBIOSIS RAW RESPONSE ===')
       console.log('id:', data.id)
       console.log('tokenAmountOut:', JSON.stringify(data.tokenAmountOut, null, 2))
@@ -79,22 +131,33 @@ export class SymbiosisProvider implements IProvider {
 
       if (!data.tokenAmountOut) return []
 
-      // Symbiosis embeds fees in the output
+      // Resolve the REAL dest-token decimals (do NOT trust the echoed 18 hint).
+      const resolvedToDecimals =
+        (await resolveToTokenDecimals(request, toChainId, data.tokenAmountOut?.decimals)) ?? 18
+
+      // Symbiosis embeds fees in the output. The implied-fee heuristic must use the
+      // RESOLVED output decimals (not the echoed 18 hint) or it computes a garbage
+      // fee (output reads as ~0 → implied fee ≈ full input).
       const inputAmountRaw = request.fromAmount
       const outputAmountRaw = data.tokenAmountOut.amount
-      
+
       const inputDecimals = data.tokenAmountIn?.decimals || 18
-      const outputDecimals = data.tokenAmountOut?.decimals || 18
-      
+      const outputDecimals = resolvedToDecimals
+
       const inputHuman = parseFloat(inputAmountRaw) / Math.pow(10, inputDecimals)
       const outputHuman = parseFloat(outputAmountRaw) / Math.pow(10, outputDecimals)
-      
+
       const impliedFeeUSD = Math.max(0, inputHuman - outputHuman).toFixed(2)
-      
-      const apiFeeUSD = data.fee?.usd?.toString() || '0'
-      const bridgeFeeUSD = parseFloat(apiFeeUSD) > 0 ? apiFeeUSD : impliedFeeUSD
+
+      // REAL fee from data.fee = (amount / 10^decimals) * priceUsd. The implied
+      // heuristic is only a last-resort fallback when data.fee is absent.
+      const realFeeUSD = computeSymbiosisFeeUSD(data.fee)
+      const bridgeFeeUSD = realFeeUSD ?? impliedFeeUSD
       const priceImpact = data.priceImpact?.toString()
 
+      // Real gas if the response carries one, else '0'. The fee no longer goes here.
+      const gasUSD = data.estimatedGas?.toString() || data.tx?.gasPrice?.toString() || '0'
+
       const approvalAddress = SYMBIOSIS_GATEWAY_MAP[fromChainId as number]
 
       let chainType: 'evm' | 'bitcoin' = 'evm'
@@ -115,77 +178,98 @@ export class SymbiosisProvider implements IProvider {
               calldata: data.tx?.data,
               to: data.tx?.to,
               chainId: data.tx?.chainId || 56,
-            })
+            }),
           })
           if (forwarderRes.ok) {
             const forwarderData = await forwarderRes.json()
             depositAddress = forwarderData.address || forwarderData.depositAddress
           } else {
-            console.warn('Symbiosis Forwarder failed, BTC deposit may not work:', await forwarderRes.text())
+            console.warn(
+              'Symbiosis Forwarder failed, BTC deposit may not work:',
+              await forwarderRes.text(),
+            )
           }
         } catch (e) {
           console.warn('Symbiosis Forwarder API call failed:', e)
         }
+
+        // Fail loudly: a BTC quote with no deposit address is unexecutable —
+        // surfacing it would let the user "pay" with nowhere to send funds.
+        if (!depositAddress) {
+          console.warn('Symbiosis: BTC source but no deposit address resolved, dropping quote')
+          return []
+        }
       }
 
-      return [{
-        provider: 'symbiosis',
-        id: data.id || Math.random().toString(36).substring(7),
-        fromAmount: request.fromAmount,
-        toAmount: data.tokenAmountOut.amount,
-        toAmountMin: data.tokenAmountOutMin?.amount || data.tokenAmountOut.amount,
-        estimatedGas: bridgeFeeUSD,
-        estimatedDuration: data.estimatedTime || 65,
-        transactionRequest: data.tx, 
-        metadata: {
-          chainType,
-          isDepositTrade,
-          ...(depositAddress ? { depositAddress } : {}),
-          ...(amountToSend ? { amountToSend } : {}),
-        },
-        fees: {
-          totalFeeUSD: bridgeFeeUSD,
-          bridgeFee: bridgeFeeUSD,
-          slippage: priceImpact,
-        },
-        toolsUsed: ['Symbiosis'],
-        routes: [{
-          type: 'bridge' as const,
-          tool: 'symbiosis',
-          toolName: 'Symbiosis Bridge',
-          action: {
-            fromToken: {
-              address: request.fromToken,
-              chainId: request.fromChain,
-              symbol: data.tokenAmountIn?.symbol || 'UNKNOWN',
-              decimals: data.tokenAmountIn?.decimals || 18
-            },
-            toToken: {
-              address: request.toToken,
-              chainId: request.toChain,
-              symbol: (data.tokenAmountOut?.symbol && data.tokenAmountOut.symbol !== 'tokenOut') ? data.tokenAmountOut.symbol : 'UNKNOWN',
-              decimals: data.tokenAmountOut?.decimals || 18
-            },
-            fromAmount: request.fromAmount,
-            toAmount: data.tokenAmountOut.amount
+      return [
+        {
+          provider: 'symbiosis',
+          id: data.id || Math.random().toString(36).substring(7),
+          fromAmount: request.fromAmount,
+          toAmount: data.tokenAmountOut.amount,
+          toAmountMin: data.tokenAmountOutMin?.amount || data.tokenAmountOut.amount,
+          toTokenDecimals: resolvedToDecimals,
+          estimatedGas: gasUSD,
+          estimatedDuration: data.estimatedTime || 65,
+          transactionRequest: data.tx,
+          metadata: {
+            chainType,
+            isDepositTrade,
+            ...(depositAddress ? { depositAddress } : {}),
+            ...(amountToSend ? { amountToSend } : {}),
           },
-          estimate: {
-            executionDuration: data.estimatedTime,
-            approvalAddress: approvalAddress,
-            feeCosts: [
-              ...(parseFloat(bridgeFeeUSD) > 0 ? [{
-                type: 'BRIDGE' as const,
-                name: 'Bridge Fee',
-                description: 'Symbiosis Protocol Fee',
-                amount: bridgeFeeUSD,
-                amountUSD: bridgeFeeUSD,
-                included: true
-              }] : [])
-            ]
-          }
-        }]
-      }]
-
+          fees: {
+            totalFeeUSD: bridgeFeeUSD,
+            bridgeFee: bridgeFeeUSD,
+            slippage: priceImpact,
+          },
+          toolsUsed: ['Symbiosis'],
+          routes: [
+            {
+              type: 'bridge' as const,
+              tool: 'symbiosis',
+              toolName: 'Symbiosis Bridge',
+              action: {
+                fromToken: {
+                  address: request.fromToken,
+                  chainId: request.fromChain,
+                  symbol: data.tokenAmountIn?.symbol || 'UNKNOWN',
+                  decimals: data.tokenAmountIn?.decimals || 18,
+                },
+                toToken: {
+                  address: request.toToken,
+                  chainId: request.toChain,
+                  symbol:
+                    data.tokenAmountOut?.symbol && data.tokenAmountOut.symbol !== 'tokenOut'
+                      ? data.tokenAmountOut.symbol
+                      : 'UNKNOWN',
+                  decimals: resolvedToDecimals,
+                },
+                fromAmount: request.fromAmount,
+                toAmount: data.tokenAmountOut.amount,
+              },
+              estimate: {
+                executionDuration: data.estimatedTime,
+                approvalAddress: approvalAddress,
+                feeCosts: [
+                  ...(parseFloat(bridgeFeeUSD) > 0
+                    ? [
+                        {
+                          type: 'BRIDGE' as const,
+                          name: 'Bridge Fee',
+                          description: 'Symbiosis Protocol Fee',
+                          amount: bridgeFeeUSD,
+                          amountUSD: bridgeFeeUSD,
+                          included: true,
+                        },
+                      ]
+                    : []),
+                ],
+              },
+            },
+          ],
+        },
+      ]
     } catch (error) {
       console.error('Symbiosis Quote Error:', error)
       return []
@@ -194,12 +278,14 @@ export class SymbiosisProvider implements IProvider {
 
   async getStatus(request: StatusRequest): Promise<StatusResponse> {
     try {
-      const response = await fetch(`${SYMBIOSIS_API_BASE}/tx/${request.fromChainId}/${request.txHash}`)
-      
+      const response = await fetch(
+        `${SYMBIOSIS_API_BASE}/tx/${request.fromChainId}/${request.txHash}`,
+      )
+
       if (!response.ok) return { status: 'NOT_FOUND' }
 
       const data = await response.json()
-      
+
       let finalStatus: TransactionStatus = 'PENDING'
       if (data.status === 'success' || data.status === 'completed') finalStatus = 'DONE'
       else if (data.status === 'failed' || data.status === 'reverted') finalStatus = 'FAILED'
@@ -207,7 +293,7 @@ export class SymbiosisProvider implements IProvider {
       return {
         status: finalStatus,
         subStatus: data.status,
-        txLink: data.explorerUrl
+        txLink: data.explorerUrl,
       }
     } catch (error) {
       console.error('Symbiosis Status Error:', error)
diff --git a/src/services/quote-aggregator.ts b/src/services/quote-aggregator.ts
index b4968cb..36fdc51 100644
--- a/src/services/quote-aggregator.ts
+++ b/src/services/quote-aggregator.ts
@@ -1,5 +1,8 @@
 import { providers } from './providers'
 import { QuoteRequest, QuoteResponse, ChainId } from '@/types/provider'
+import { rankQuotes } from './ranking'
+import { validateQuoteRequest } from '@/lib/chain-address'
+import { ChainTokenService } from './chain-token-service'
 
 const PROVIDER_TIMEOUT_MS = 30000
 const QUOTE_VALIDITY_MS = 60000
@@ -25,21 +28,16 @@ function normalizeChainId(id: ChainId): ChainId {
   return id
 }
 
-// Provider reliability scores
-const PROVIDER_RELIABILITY: Record<string, number> = {
-  'cctp': 98,           
-  'lifi': 95,
-  'rango': 90,
-  'symbiosis': 88,
-  'rubic': 85,
-  'near-intents': 80,
-}
-
 export interface AggregatedQuoteResponse {
   quotes: QuoteResponse[]
   bestQuote: QuoteResponse | null
   expiresAt: number
   fetchedAt: number
+  /** True when the request was rejected before fan-out (e.g. unsupported chain). */
+  unsupported?: boolean
+  /** Human-readable reason when the request can't be quoted (unsupported chain
+   *  or an address that doesn't match the chain's address space). */
+  reason?: string
   providerStats: {
     succeeded: string[]
     failed: string[]
@@ -48,6 +46,28 @@ export interface AggregatedQuoteResponse {
   }
 }
 
+/**
+ * Best-effort resolve the source token's decimals when the caller omitted them.
+ * Rubic falls back to 18 (rubic.ts) which over/under-scales the input amount by
+ * 10^(realDecimals-18) → wildly wrong quotes. Resolving from the cached token
+ * list (ChainTokenService, 5-min cache) avoids that footgun. Returns undefined
+ * if it can't resolve, leaving providers on their own fallback.
+ */
+async function resolveFromTokenDecimals(
+  fromChain: ChainId,
+  fromToken: string
+): Promise<number | undefined> {
+  try {
+    const tokens = await ChainTokenService.getTokens(String(fromChain))
+    const target = fromToken.toLowerCase()
+    const match = tokens.find((t) => t.address.toLowerCase() === target)
+    return match?.decimals
+  } catch (e) {
+    console.warn('[QuoteAggregator] Could not resolve fromTokenDecimals:', String(e))
+    return undefined
+  }
+}
+
 // Wrap provider call with timeout
 async function withTimeout<T>(
   promise: Promise<T>, 
@@ -75,45 +95,6 @@ async function withTimeout<T>(
   }
 }
 
-/**
- * Calculate a secondary score for tie-breaking when output amounts are equal.
- * Factors in: total fees (USD), gas cost, speed, and provider reliability.
- * Higher score = better route.
- */
-function calculateTieBreakerScore(quote: QuoteResponse): number {
-  const totalFeeUSD = parseFloat(quote.fees?.totalFeeUSD || '0')
-  const gasCostUSD = parseFloat(quote.estimatedGas || '0')
-  const duration = quote.estimatedDuration || 600
-  const reliability = PROVIDER_RELIABILITY[quote.provider] || 50
-
-  // Fee score: 0-30 points, lower fees = higher score
-  const totalCost = totalFeeUSD + gasCostUSD
-  const feeScore = Math.max(0, 30 * (1 - Math.min(totalCost, 30) / 30))
-
-  // Speed score: 0-10 points, faster = higher score
-  const speedScore = Math.max(0, 10 * (1 - Math.min(duration, 1800) / 1800))
-
-  // Reliability score: 0-10 points
-  const reliabilityScore = (reliability / 100) * 10
-
-  return feeScore + speedScore + reliabilityScore
-}
-
-function rankQuotes(quotes: QuoteResponse[]): QuoteResponse[] {
-  return quotes.sort((a, b) => {
-    const amountA = BigInt(a.toAmount || '0')
-    const amountB = BigInt(b.toAmount || '0')
-
-    // Primary: Output amount (higher = better)
-    if (amountA !== amountB) {
-      return amountA > amountB ? -1 : 1
-    }
-
-    // Equal output: use fee-aware tie-breaker score (higher = better)
-    return calculateTieBreakerScore(b) - calculateTieBreakerScore(a)
-  })
-}
-
 export const QuoteAggregator = {
   async getQuotes(request: QuoteRequest): Promise<AggregatedQuoteResponse> {
     const fetchedAt = Date.now()
@@ -133,6 +114,41 @@ export const QuoteAggregator = {
       errors: {} as Record<string, string>,
     }
 
+    // Central request validation BEFORE fan-out: reject unsupported chains
+    // (A5 — 'other' family has no executable signing path) and addresses that
+    // don't match the chain's address space (A4). Returning early surfaces an
+    // honest reason instead of silently fanning out → "no routes".
+    const validation = validateQuoteRequest(normalizedRequest)
+    if (!validation.ok) {
+      console.warn(`[QuoteAggregator] Request rejected: ${validation.reason}`)
+      return {
+        quotes: [],
+        bestQuote: null,
+        unsupported: !!validation.unsupported,
+        reason: validation.reason,
+        expiresAt,
+        fetchedAt,
+        providerStats,
+      }
+    }
+
+    // U3: ensure fromTokenDecimals so Rubic (rubic.ts: || 18) can't mis-scale
+    // the input amount. Best-effort, cached; leaves it undefined if unresolved.
+    if (normalizedRequest.fromTokenDecimals === undefined) {
+      const resolved = await resolveFromTokenDecimals(
+        normalizedRequest.fromChain,
+        normalizedRequest.fromToken
+      )
+      if (resolved !== undefined) {
+        normalizedRequest.fromTokenDecimals = resolved
+        console.log(`[QuoteAggregator] Resolved fromTokenDecimals=${resolved}`)
+      } else {
+        console.warn(
+          '[QuoteAggregator] fromTokenDecimals missing and unresolved; providers will use their fallback'
+        )
+      }
+    }
+
     console.log('=== QUOTE AGGREGATOR START ===')
     console.log(`Querying ${providers.length} providers:`, providers.map(p => p.name))
     console.log('Request:', JSON.stringify(normalizedRequest, null, 2))
@@ -186,7 +202,10 @@ export const QuoteAggregator = {
     console.log('Total Quotes:', allQuotes.length)
 
     // Rank quotes with tie-breakers
-    const rankedQuotes = rankQuotes(allQuotes)
+    // Pass the authoritative destination-token decimals so a provider that
+    // mislabels them (e.g. reports 6-dec USDC as 18) can't win the ranking,
+    // even if it's the majority. Falls back to consensus when not supplied.
+    const rankedQuotes = rankQuotes(allQuotes, request.toTokenDecimals)
 
     return {
       quotes: rankedQuotes,
diff --git a/src/services/ranking.ts b/src/services/ranking.ts
new file mode 100644
index 0000000..f97da51
--- /dev/null
+++ b/src/services/ranking.ts
@@ -0,0 +1,137 @@
+import type { QuoteResponse } from '@/types/provider'
+
+/**
+ * Quote ranking — pure, no provider/SDK imports (so it is unit-testable offline).
+ *
+ * Why this exists: ranking quotes by raw `BigInt(toAmount)` is unsafe because
+ * providers disagree on the destination token's decimals (e.g. Symbiosis/Rubic
+ * mislabel 6-decimal USDC as 18). Comparing raw integers across mismatched
+ * decimals can rank a dust-output route as "best". Instead we:
+ *   1. normalize each quote's output to human units using its declared decimals,
+ *   2. distrust any quote whose decimals disagree with the cross-provider
+ *      consensus (the destination token is the same for every quote in a request),
+ *   3. subtract clearly on-top fees (FeeCost.included === false),
+ *   4. break near-ties with a fee/speed/reliability score.
+ */
+
+const PROVIDER_RELIABILITY: Record<string, number> = {
+  cctp: 98,
+  lifi: 95,
+  rango: 90,
+  symbiosis: 88,
+  rubic: 85,
+  'near-intents': 80,
+}
+
+// Net outputs within this relative gap are treated as a tie → use the score.
+const TIE_EPSILON = 1e-6
+
+/** Destination-token decimals a quote declares (top-level field wins, else route token). */
+export function declaredDecimals(quote: QuoteResponse): number {
+  if (typeof quote.toTokenDecimals === 'number') return quote.toTokenDecimals
+  const routeDec = quote.routes?.[0]?.action?.toToken?.decimals
+  if (typeof routeDec === 'number') return routeDec
+  return 18
+}
+
+/**
+ * The decimals the majority of quotes agree on for the (shared) destination
+ * token. Returns undefined if there are no quotes. Ties broken toward the
+ * smaller value (conservative).
+ */
+export function consensusDecimals(quotes: QuoteResponse[]): number | undefined {
+  if (quotes.length === 0) return undefined
+  const counts = new Map<number, number>()
+  for (const q of quotes) {
+    const d = declaredDecimals(q)
+    counts.set(d, (counts.get(d) || 0) + 1)
+  }
+  let best: number | undefined
+  let bestCount = -1
+  for (const [dec, count] of counts) {
+    if (count > bestCount || (count === bestCount && (best === undefined || dec < best))) {
+      best = dec
+      bestCount = count
+    }
+  }
+  return best
+}
+
+/** Sum of on-top fee costs (included === false) in USD across a quote's routes. */
+export function onTopCostUSD(quote: QuoteResponse): number {
+  let total = 0
+  for (const route of quote.routes || []) {
+    for (const fee of route.estimate?.feeCosts || []) {
+      if (fee.included === false) total += parseFloat(fee.amountUSD || '0') || 0
+    }
+  }
+  return total
+}
+
+/**
+ * Net output of a quote in human units of the destination token, minus on-top
+ * costs. `decimals` is the canonical decimals to normalize by (the consensus for
+ * trusted quotes; the quote's own for untrusted).
+ */
+export function netOutput(quote: QuoteResponse, decimals: number): number {
+  const raw = Number(quote.toAmount || '0')
+  const human = raw / Math.pow(10, decimals)
+  const onTopUSD = onTopCostUSD(quote)
+  // Convert on-top USD fees into destination-token units when the token's USD
+  // price is known (a $20 fee on a $2000 token costs 0.01 token, not 20). Falls
+  // back to USD ≈ token units, correct for the common ~$1 stablecoin destination.
+  const price = quote.toTokenPriceUSD
+  const onTopInTokenUnits = typeof price === 'number' && price > 0 ? onTopUSD / price : onTopUSD
+  return human - onTopInTokenUnits
+}
+
+/** Tie-breaker when net outputs are within epsilon. Higher = better. */
+export function tieBreakerScore(quote: QuoteResponse): number {
+  const totalFeeUSD = parseFloat(quote.fees?.totalFeeUSD || '0') || 0
+  const duration = quote.estimatedDuration && quote.estimatedDuration > 0 ? quote.estimatedDuration : 600
+  const reliability = PROVIDER_RELIABILITY[quote.provider] || 50
+
+  const feeScore = Math.max(0, 30 * (1 - Math.min(totalFeeUSD, 30) / 30))
+  const speedScore = Math.max(0, 10 * (1 - Math.min(duration, 1800) / 1800))
+  const reliabilityScore = (reliability / 100) * 10
+
+  return feeScore + speedScore + reliabilityScore
+}
+
+/**
+ * Rank quotes best-first.
+ *
+ * Decimals are a FACT about the (shared) destination token, not a vote. When the
+ * caller knows the authoritative destination-token decimals (the aggregator does —
+ * every quote in a request targets the same token), pass `refDecimals`: any quote
+ * whose declared decimals disagree is "untrusted" and ranks below all trusted
+ * quotes, regardless of raw amount. This holds even when the MAJORITY of providers
+ * mislabel the token (majority-vote consensus would fail there).
+ *
+ * When `refDecimals` is omitted (e.g. offline tests with no known reference),
+ * fall back to the most-common declared decimals as a best-effort consensus.
+ */
+export function rankQuotes(quotes: QuoteResponse[], refDecimals?: number): QuoteResponse[] {
+  if (quotes.length <= 1) return [...quotes]
+  // Authoritative reference wins; otherwise best-effort majority consensus.
+  const reference = typeof refDecimals === 'number' ? refDecimals : consensusDecimals(quotes)
+
+  const decimalsFor = (q: QuoteResponse) => declaredDecimals(q)
+  const isTrusted = (q: QuoteResponse) => reference === undefined || decimalsFor(q) === reference
+  // Trusted quotes normalize by the reference; untrusted by their own (best effort).
+  const netFor = (q: QuoteResponse) => netOutput(q, isTrusted(q) ? (reference as number) : decimalsFor(q))
+
+  return [...quotes].sort((a, b) => {
+    const ta = isTrusted(a)
+    const tb = isTrusted(b)
+    if (ta !== tb) return ta ? -1 : 1 // trusted before untrusted
+
+    const na = netFor(a)
+    const nb = netFor(b)
+    const denom = Math.max(1, Math.abs(na), Math.abs(nb))
+    if (Math.abs(na - nb) / denom > TIE_EPSILON) {
+      return nb - na // higher net output first
+    }
+    return tieBreakerScore(b) - tieBreakerScore(a) // near-tie → score
+  })
+}
diff --git a/src/store/user.ts b/src/store/user.ts
deleted file mode 100644
index 3d83ea9..0000000
--- a/src/store/user.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { create } from 'zustand'
-
-interface WalletState {
-  walletAddress: string | null
-  isConnected: boolean
-  chainType: 'evm' | 'solana' | 'bitcoin' | null
-
-  setWallet: (address: string | null, chainType?: 'evm' | 'solana' | 'bitcoin' | null) => void
-  disconnect: () => void
-}
-
-export const useWalletStore = create<WalletState>((set) => ({
-  walletAddress: null,
-  isConnected: false,
-  chainType: null,
-
-  setWallet: (address, chainType = null) =>
-    set({ walletAddress: address, isConnected: !!address, chainType }),
-
-  disconnect: () =>
-    set({ walletAddress: null, isConnected: false, chainType: null }),
-}))
-
-// Keep backward compat alias
-export const useUserStore = useWalletStore
diff --git a/src/types/provider.ts b/src/types/provider.ts
index 833e7bd..6a13469 100644
--- a/src/types/provider.ts
+++ b/src/types/provider.ts
@@ -15,8 +15,11 @@ export interface QuoteRequest {
   fromAmount: string 
   fromAddress: string 
   toAddress?: string  
-  slippage?: number 
+  slippage?: number
   fromTokenDecimals?: number // Required for Rubic
+  /** Authoritative destination-token decimals — used to rank quotes fairly
+   *  (a provider that mislabels the dest token's decimals can't win). */
+  toTokenDecimals?: number
 }
 
 export interface FeeCost {
@@ -54,13 +57,20 @@ export interface QuoteStep {
 }
 
 export interface QuoteResponse {
-  provider: string 
-  id: string 
+  provider: string
+  id: string
   fromAmount: string
   toAmount: string
   toAmountMin: string
-  estimatedGas: string 
-  estimatedDuration: number 
+  estimatedGas: string
+  estimatedDuration: number
+  /** REAL decimals of the destination token. Providers MUST set this from the
+   *  live response (never hardcode). Used to normalize toAmount for fair ranking. */
+  toTokenDecimals?: number
+  /** OPTIONAL refinement — USD price of 1 whole destination token (only some providers expose it). */
+  toTokenPriceUSD?: number
+  /** OPTIONAL — provider-supplied USD value of the output (LiFi/NEAR have it; Rubic/Symbiosis do not). */
+  toAmountUSD?: string
   routes: QuoteStep[]
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   transactionRequest?: any 
@@ -75,21 +85,24 @@ export interface QuoteResponse {
   }
   toolsUsed?: string[] 
   metadata?: {
-    chainType?: 'evm' | 'solana' | 'bitcoin'
+    chainType?: 'evm' | 'solana' | 'bitcoin' | 'other'
     isDepositTrade?: boolean
     depositAddress?: string
+    depositMemo?: string
     amountToSend?: string
     [key: string]: unknown
-  }  
+  }
 }
 
 export interface StatusRequest {
   txHash: string
   fromChainId: ChainId
   toChainId: ChainId
-  bridge?: string 
-  requestId?: string 
+  bridge?: string
+  requestId?: string
   depositAddress?: string
+  /** Memo/tag for deposit chains that require it (NEAR Intents status lookup). */
+  depositMemo?: string
 }
 
 export type TransactionStatus = 'PENDING' | 'DONE' | 'FAILED' | 'NOT_FOUND'