0xtrails 0.13.0 → 0.13.2

package/src/prices.ts

@@ -1,528 +0,0 @@
-import type { Token, TokenPrice } from "@0xtrails/api"
-import { type QueryClient, useQuery } from "@tanstack/react-query"
-import { zeroAddress } from "viem"
-import { logger } from "./logger.js"
-import { parseLocaleNumber } from "./localeUtils.js"
-import { queryClient as defaultQueryClient } from "./query/client.js"
-import { useTrailsClient, type TrailsClient } from "./trailsClient.js"
-import { MINUTE_MS, SECOND_MS, retryDelay } from "./utils/time.js"
-import { useUserActivityContext } from "./widget/providers/UserActivityProvider.js"
-import { isValidNumber, isNonNegativeNumber } from "./utils/validation.js"
-
-import { normalizeAddress } from "./utils/address.js"
-
-export const priceKeys = {
-  all: ["tokenPrices"] as const,
-}
-// Local storage cache configuration
-const LOCAL_STORAGE_CACHE_KEY = "trails_token_prices_cache"
-const LOCAL_STORAGE_CACHE_DURATION = MINUTE_MS
-
-// Global caching configuration
-const CACHE_CONFIG = {
-  // Time configurations - matches API cache of 90 seconds
-  staleTime: 90 * SECOND_MS,
-  gcTime: 90 * SECOND_MS,
-  refetchInterval: 90 * SECOND_MS,
-
-  // Retry configurations
-  retry: 2,
-  retryDelay,
-
-  // Refetch behaviors
-  refetchOnWindowFocus: false,
-  refetchOnReconnect: true,
-  refetchIntervalInBackground: false,
-
-  // Retry logic for specific error types
-  shouldRetry: (failureCount: number, error: any) => {
-    if (error && "status" in error && error.status === 404) return false
-    if (failureCount < 2) return true
-    return false
-  },
-} as const
-
-// Extract common query options for reuse
-const COMMON_QUERY_OPTIONS = {
-  staleTime: CACHE_CONFIG.staleTime,
-  gcTime: CACHE_CONFIG.gcTime,
-  retry: CACHE_CONFIG.shouldRetry,
-  retryDelay: CACHE_CONFIG.retryDelay,
-  refetchOnWindowFocus: CACHE_CONFIG.refetchOnWindowFocus,
-  refetchOnReconnect: CACHE_CONFIG.refetchOnReconnect,
-  refetchInterval: CACHE_CONFIG.refetchInterval,
-  refetchIntervalInBackground: CACHE_CONFIG.refetchIntervalInBackground,
-} as const
-
-// Local storage cache helpers
-interface TokenPriceEntry {
-  price: TokenPrice
-  timestamp: number
-}
-
-interface TokenPriceCache {
-  // Indexed by chainId -> tokenAddress (lowercase) -> price data
-  prices: Record<number, Record<string, TokenPriceEntry>>
-  lastCleanup: number
-}
-
-const getLocalStorageCache = (): TokenPriceCache => {
-  try {
-    const cached = localStorage.getItem(LOCAL_STORAGE_CACHE_KEY)
-    if (!cached) {
-      return {
-        prices: {},
-        lastCleanup: Date.now(),
-      }
-    }
-
-    const parsed = JSON.parse(cached) as TokenPriceCache
-    // Ensure structure is correct
-    if (!parsed.prices) {
-      return {
-        prices: {},
-        lastCleanup: Date.now(),
-      }
-    }
-    return parsed
-  } catch (error) {
-    logger.console.warn(
-      "[trails-sdk] Failed to parse localStorage cache:",
-      error,
-    )
-    return {
-      prices: {},
-      lastCleanup: Date.now(),
-    }
-  }
-}
-
-const setLocalStorageCache = (cache: TokenPriceCache): void => {
-  try {
-    localStorage.setItem(LOCAL_STORAGE_CACHE_KEY, JSON.stringify(cache))
-  } catch (error) {
-    logger.console.warn(
-      "[trails-sdk] Failed to save localStorage cache:",
-      error,
-    )
-  }
-}
-
-const getCachedTokenPrice = (
-  chainId: number,
-  tokenAddress: string,
-): TokenPrice | null => {
-  const cache = getLocalStorageCache()
-  const chainPrices = cache.prices[chainId]
-  if (!chainPrices) return null
-
-  const entry = chainPrices[normalizeAddress(tokenAddress)]
-  if (!entry) return null
-
-  const now = Date.now()
-  const age = now - entry.timestamp
-
-  // Check if cache is still valid (within 60 seconds)
-  if (age > LOCAL_STORAGE_CACHE_DURATION) {
-    logger.console.debug(
-      `[trails-sdk] Cache expired for ${chainId}:${tokenAddress}, age: ${age}ms`,
-    )
-    return null
-  }
-
-  logger.console.debug(
-    `[trails-sdk] Using cached price for ${chainId}:${tokenAddress}, age: ${age}ms`,
-  )
-  return entry.price
-}
-
-const getCachedPricesForTokens = (tokens: Token[]): TokenPrice[] | null => {
-  if (tokens.length === 0) return []
-
-  const cache = getLocalStorageCache()
-  const now = Date.now()
-  const results: TokenPrice[] = []
-
-  // Check if all tokens have valid cached prices
-  for (const token of tokens) {
-    const chainPrices = cache.prices[token.chainId]
-    if (!chainPrices) return null // Missing chain data
-
-    const tokenAddress = (token.tokenAddress || zeroAddress).toLowerCase()
-    const entry = chainPrices[tokenAddress]
-
-    if (!entry) return null // Missing token price
-
-    const age = now - entry.timestamp
-    if (age > LOCAL_STORAGE_CACHE_DURATION) {
-      return null // Expired price found
-    }
-
-    results.push(entry.price)
-  }
-
-  logger.console.debug(
-    `[trails-sdk] Using ${results.length} cached prices for batch request`,
-  )
-  return results
-}
-
-const setCachedTokenPrices = (prices: TokenPrice[]): void => {
-  const cache = getLocalStorageCache()
-  const now = Date.now()
-
-  // Store each price individually
-  for (const price of prices) {
-    const chainId = price.token.chainId
-    const tokenAddress = (price.token.tokenAddress || zeroAddress).toLowerCase()
-
-    // Ensure chain object exists
-    if (!cache.prices[chainId]) {
-      cache.prices[chainId] = {}
-    }
-
-    // Store the price entry
-    cache.prices[chainId][tokenAddress] = {
-      price,
-      timestamp: now,
-    }
-  }
-
-  // Clean up old entries periodically (every 5 minutes)
-  if (now - cache.lastCleanup > 5 * MINUTE_MS) {
-    cleanupExpiredEntries(cache)
-    cache.lastCleanup = now
-  }
-
-  setLocalStorageCache(cache)
-  logger.console.debug(`[trails-sdk] Cached ${prices.length} token prices`)
-}
-
-const cleanupExpiredEntries = (cache: TokenPriceCache): void => {
-  const now = Date.now()
-  let removed = 0
-
-  for (const chainId in cache.prices) {
-    const chainPrices = cache.prices[chainId]
-    if (!chainPrices) continue
-
-    for (const tokenAddress in chainPrices) {
-      const entry = chainPrices[tokenAddress]
-      if (entry && now - entry.timestamp > LOCAL_STORAGE_CACHE_DURATION) {
-        delete chainPrices[tokenAddress]
-        removed++
-      }
-    }
-    // Remove empty chain objects
-    if (Object.keys(chainPrices).length === 0) {
-      delete cache.prices[chainId]
-    }
-  }
-
-  if (removed > 0) {
-    logger.console.debug(
-      `[trails-sdk] Cleaned up ${removed} expired cache entries`,
-    )
-  }
-}
-
-// Periodic cleanup is now handled in setCachedTokenPrices when needed
-
-// Cache key generation methods
-const createTokenCacheKey = (token: Token): string => {
-  const tokenAddress = (token.tokenAddress || "").toLowerCase()
-  const chainId = Number(token.chainId || 0)
-  const tokenSymbol = (token.tokenSymbol || "").toUpperCase()
-  return `${tokenAddress}-${chainId}-${tokenSymbol}`
-}
-
-const createBatchCacheKey = (
-  tokens: Token[],
-): (string | number | string[])[] => {
-  return [
-    "tokenPrices",
-    "batch",
-    tokens.length,
-    tokens.map(createTokenCacheKey).sort(),
-  ]
-}
-
-const createSingleCacheKey = (token?: Token | null): (string | null)[] => {
-  return ["tokenPrices", "single", token ? createTokenCacheKey(token) : null]
-}
-
-// Separate fetch function for token prices
-export const fetchGetTokenPrices = async (
-  trailsClient: TrailsClient,
-  tokens: Token[],
-): Promise<TokenPrice[]> => {
-  if (!trailsClient) {
-    throw new Error("Trails client is required")
-  }
-
-  if (tokens.length === 0) {
-    return [] as TokenPrice[]
-  }
-
-  // First, check if all tokens have cached prices
-  const cachedPrices = getCachedPricesForTokens(tokens)
-  if (cachedPrices) {
-    return cachedPrices
-  }
-
-  // If not all cached, check which ones we need to fetch
-  const tokensToFetch: Token[] = []
-  const cachedResults: TokenPrice[] = []
-
-  for (const token of tokens) {
-    const cached = getCachedTokenPrice(
-      token.chainId,
-      token.tokenAddress || zeroAddress,
-    )
-    if (cached) {
-      cachedResults.push(cached)
-    } else {
-      tokensToFetch.push(token)
-    }
-  }
-
-  // If all tokens were cached individually
-  if (tokensToFetch.length === 0) {
-    logger.console.debug(
-      `[trails-sdk] All ${tokens.length} token prices found in cache`,
-    )
-    return cachedResults
-  }
-
-  // Fetch only the missing prices
-  logger.console.debug(
-    `[trails-sdk] Fetching ${tokensToFetch.length} prices, ${cachedResults.length} from cache`,
-  )
-
-  try {
-    const res = await trailsClient.getTokenPrices({ tokens: tokensToFetch })
-    const fetchedPrices = res?.tokenPrices || []
-
-    // Store all fetched prices in cache
-    if (fetchedPrices.length > 0) {
-      setCachedTokenPrices(fetchedPrices)
-    }
-
-    // Combine cached and fetched results, maintaining original order
-    const allPrices: TokenPrice[] = []
-    for (const token of tokens) {
-      const cached = cachedResults.find(
-        (p) =>
-          p.token.chainId === token.chainId &&
-          p.token.tokenAddress?.toLowerCase() ===
-            (token.tokenAddress || zeroAddress).toLowerCase(),
-      )
-      if (cached) {
-        allPrices.push(cached)
-      } else {
-        const fetched = fetchedPrices.find(
-          (p) =>
-            p.token.chainId === token.chainId &&
-            p.token.tokenAddress?.toLowerCase() ===
-              (token.tokenAddress || zeroAddress).toLowerCase(),
-        )
-        if (fetched) {
-          allPrices.push(fetched)
-        }
-      }
-    }
-
-    return allPrices
-  } catch (error) {
-    logger.console.error("[trails-sdk] Failed to fetch token prices:", error)
-    throw error
-  }
-}
-
-export function normalizeToken(
-  token: Token & {
-    tokenID?: string
-    symbol?: string
-    contractAddress?: string
-    tokenId?: string
-  },
-): Token {
-  return {
-    chainId: token.chainId,
-    tokenAddress: token.tokenAddress || token.contractAddress || zeroAddress,
-    tokenSymbol:
-      token.tokenSymbol || token.tokenId || token.tokenID || token.symbol,
-  }
-}
-
-export const getTokenPrices = async (
-  trailsClient: TrailsClient,
-  tokens: Token[],
-): Promise<TokenPrice[]> => {
-  tokens = tokens.map(normalizeToken)
-  return fetchGetTokenPrices(trailsClient, tokens)
-}
-
-export const getTokenPrice = async (
-  trailsClient: TrailsClient,
-  token: Token,
-): Promise<TokenPrice | null> => {
-  token = normalizeToken(token)
-  const prices = await fetchGetTokenPrices(trailsClient, [token])
-  return prices?.length ? (prices[0] ?? null) : null
-}
-
-export const useTokenPrices = (tokens: Token[], disabled?: boolean) => {
-  const trailsClient = useTrailsClient()
-  const { isUserActive } = useUserActivityContext()
-  tokens = tokens.map(normalizeToken)
-
-  const { data: tokenPrices, isLoading: isLoadingTokenPrices } = useQuery({
-    queryKey: createBatchCacheKey(tokens),
-    queryFn: () => getTokenPrices(trailsClient, tokens),
-    enabled: !disabled && tokens.length > 0 && !!trailsClient,
-    ...COMMON_QUERY_OPTIONS,
-    refetchInterval: isUserActive ? CACHE_CONFIG.refetchInterval : false, // Pause polling when user is inactive
-  })
-
-  return {
-    tokenPrices,
-    isLoadingTokenPrices,
-  }
-}
-
-export const useTokenPrice = (token?: Token | null) => {
-  const trailsClient = useTrailsClient()
-  const { isUserActive } = useUserActivityContext()
-
-  const { data: tokenPrice, isLoading: isLoadingTokenPrice } = useQuery({
-    queryKey: createSingleCacheKey(token),
-    queryFn: () =>
-      token && trailsClient ? getTokenPrice(trailsClient, token) : null,
-    enabled: !!token && !!trailsClient,
-    ...COMMON_QUERY_OPTIONS,
-    refetchInterval: isUserActive ? CACHE_CONFIG.refetchInterval : false, // Pause polling when user is inactive
-  })
-
-  return {
-    tokenPrice,
-    isLoadingTokenPrice,
-  }
-}
-
-// Cache invalidation utility function
-export function invalidateTokenPricesCache(token?: Token, qc?: QueryClient) {
-  const client = qc ?? defaultQueryClient
-  if (token) {
-    // Invalidate specific token price using consistent cache key
-    client.invalidateQueries({
-      queryKey: createSingleCacheKey(token),
-    })
-  } else {
-    // Invalidate all token price queries
-    client.invalidateQueries({
-      queryKey: ["tokenPrices"],
-    })
-  }
-
-  // Also clear localStorage cache
-  clearLocalStoragePriceCache()
-}
-
-// Clear all localStorage price cache
-export function clearLocalStoragePriceCache(): void {
-  try {
-    localStorage.removeItem(LOCAL_STORAGE_CACHE_KEY)
-    logger.console.debug("[trails-sdk] Cleared localStorage price cache")
-  } catch (error) {
-    logger.console.warn(
-      "[trails-sdk] Failed to clear localStorage cache:",
-      error,
-    )
-  }
-}
-
-// Export function to manually trigger cleanup if needed
-export function cleanupExpiredPriceCache(): void {
-  const cache = getLocalStorageCache()
-  cleanupExpiredEntries(cache)
-  setLocalStorageCache(cache)
-}
-
-export function calcAmountUsdPrice({
-  amount,
-  usdPrice,
-}: {
-  amount: number | string
-  usdPrice: string | number | null | undefined
-}) {
-  const sanitizedAmount = normalizeNumber(amount)
-  const sanitizedPrice = normalizeNumber(usdPrice)
-
-  // Validate inputs
-  if (!isNonNegativeNumber(sanitizedAmount)) {
-    return 0
-  }
-  if (!isNonNegativeNumber(sanitizedPrice)) {
-    return 0
-  }
-
-  const result = sanitizedAmount * sanitizedPrice
-
-  // Validate result
-  if (!isValidNumber(result)) {
-    logger.console.error("[trails-sdk] Error calculating amount USD:", {
-      sanitizedAmount,
-      sanitizedPrice,
-      result,
-      amount,
-      usdPrice,
-    })
-    return 0
-  }
-
-  return result
-}
-
-export function normalizeNumber(
-  number: number | string | null | undefined,
-): number {
-  if (number === null || number === undefined) {
-    return 0
-  }
-
-  // If already a number, return it directly
-  if (typeof number === "number") {
-    // Validate the number
-    if (!isValidNumber(number)) {
-      logger.console.error("[trails-sdk] Invalid number value:", number)
-      return 0
-    }
-    return number
-  }
-
-  // Only parse strings that might be locale-formatted
-  // This should ideally only be used for user input, not internal calculations
-  const normalized = parseLocaleNumber(number)
-
-  // Return 0 for invalid numbers
-  if (!isValidNumber(normalized)) {
-    logger.console.error("[trails-sdk] Error normalizing number string:", {
-      number,
-      normalized,
-    })
-    return 0
-  }
-
-  return normalized
-}
-
-// Format TVL (Total Value Locked) for display
-export function formatTvl(tvl: number): string {
-  if (tvl >= 1e9) return `$${(tvl / 1e9).toFixed(1)}B`
-  if (tvl >= 1e6) return `$${(tvl / 1e6).toFixed(1)}M`
-  if (tvl >= 1e3) return `$${(tvl / 1e3).toFixed(1)}K`
-  return `$${tvl.toFixed(0)}`
-}
-
-export { isValidNumeric, isValidInteger } from "./utils/validation.js"

package/src/useGasEstimation.ts

@@ -1,147 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import type { QueryClient } from "@tanstack/react-query"
-import type { PublicClient } from "viem"
-import { estimateGasLimit, getFeeData } from "./estimate.js"
-import { MINUTE_MS, SECOND_MS } from "./utils/time.js"
-
-/**
- * Parameters for gas limit estimation
- */
-export interface GasEstimationParams {
-  account: string
-  to: string | bigint | number
-  data: string | bigint | number
-  value: bigint | string | number
-}
-
-/**
- * Helper to create a consistent query key for gas estimation
- */
-function createGasEstimationQueryKey(
-  chainId: number | undefined,
-  params: GasEstimationParams | null | undefined,
-) {
-  return [
-    "gas-limit",
-    chainId,
-    params?.account,
-    params?.to,
-    params?.data,
-    params?.value?.toString(),
-  ] as const
-}
-
-/**
- * Hook to estimate gas limit with caching
- *
- * Gas LIMIT is cached for 60 seconds
- */
-export async function fetchCachedGasLimit(
-  queryClient: QueryClient,
-  publicClient: PublicClient,
-  params: GasEstimationParams,
-  logContext: string = "transaction",
-): Promise<bigint | undefined> {
-  try {
-    const result = await queryClient.fetchQuery({
-      queryKey: createGasEstimationQueryKey(publicClient.chain?.id, params),
-      queryFn: async () => {
-        const gasLimit = await estimateGasLimit(
-          publicClient,
-          params,
-          logContext,
-        )
-        // React Query doesn't allow undefined return values
-        // Return null instead and convert back to undefined outside
-        if (gasLimit === undefined) {
-          return null
-        }
-        return gasLimit
-      },
-      staleTime: MINUTE_MS, // 60 seconds
-      gcTime: 2 * MINUTE_MS, // Keep in cache for 2 minutes
-      retry: 2, // Retry up to 2 times on failure
-    })
-    // Convert null back to undefined for the caller
-    return result === null ? undefined : result
-  } catch (_error) {
-    // If query fails, return undefined to allow caller to handle gracefully
-    return undefined
-  }
-}
-
-export function useGasEstimation(
-  publicClient: PublicClient | null | undefined,
-  params: GasEstimationParams | null | undefined,
-  enabled: boolean = true,
-) {
-  return useQuery({
-    queryKey: createGasEstimationQueryKey(publicClient?.chain?.id, params),
-    queryFn: async () => {
-      if (!publicClient || !params) {
-        throw new Error("Missing publicClient or params for gas estimation")
-      }
-      const gasLimit = await estimateGasLimit(publicClient, params)
-      if (gasLimit === undefined) {
-        return null
-      }
-      return gasLimit
-    },
-    enabled: enabled && !!publicClient && !!params,
-    staleTime: MINUTE_MS, // 60 seconds
-    gcTime: 2 * MINUTE_MS, // Keep in cache for 2 minutes
-    retry: 2, // Retry up to 2 times on failure
-    retryDelay: SECOND_MS, // Wait 1 second between retries
-  })
-}
-
-/**
- * Helper function to create gas estimation params
- * Useful for ensuring type safety and consistency
- */
-export function createGasEstimationParams(
-  account: string,
-  to: string,
-  data: string,
-  value: bigint | string | number,
-): GasEstimationParams {
-  return {
-    account,
-    to,
-    data,
-    value,
-  }
-}
-
-/**
- * Helper to create a consistent query key for fee data
- */
-function createFeeDataQueryKey(chainId: number | undefined, context: string) {
-  return ["gas-fee-data", chainId, context] as const
-}
-
-/**
- * Fetch gas fee data (prices) with SHORT-TERM caching
- *
- * Gas PRICES are cached for only 5 seconds
- */
-export async function fetchCachedFeeData(
-  queryClient: QueryClient,
-  publicClient: PublicClient,
-  context: string = "default",
-): Promise<{
-  maxFeePerGas?: bigint
-  maxPriorityFeePerGas?: bigint
-  gasPrice?: bigint
-}> {
-  return await queryClient.fetchQuery({
-    queryKey: createFeeDataQueryKey(publicClient.chain?.id, context),
-    queryFn: async () => {
-      const feeData = await getFeeData(publicClient)
-      return feeData
-    },
-    staleTime: 5 * SECOND_MS, // 5 seconds
-    gcTime: 10 * SECOND_MS, // Keep in cache for 10 seconds
-    retry: 2,
-  })
-}

package/src/widget/assets/Binance_Icon_Logo.svg

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 16.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg version="1.1" id="Your_design" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px"
-	 y="0px" width="126.611px" height="126.611px" viewBox="0 0 126.611 126.611" enable-background="new 0 0 126.611 126.611"
-	 xml:space="preserve">
-<polygon fill="#F3BA2F" points="38.171,53.203 62.759,28.616 87.36,53.216 101.667,38.909 62.759,0 23.864,38.896 "/>
-<rect x="3.644" y="53.188" transform="matrix(0.7071 0.7071 -0.7071 0.7071 48.7933 8.8106)" fill="#F3BA2F" width="20.233" height="20.234"/>
-<polygon fill="#F3BA2F" points="38.171,73.408 62.759,97.995 87.359,73.396 101.674,87.695 101.667,87.703 62.759,126.611 
-	23.863,87.716 23.843,87.696 "/>
-<rect x="101.64" y="53.189" transform="matrix(-0.7071 0.7071 -0.7071 -0.7071 235.5457 29.0503)" fill="#F3BA2F" width="20.234" height="20.233"/>
-<polygon fill="#F3BA2F" points="77.271,63.298 77.277,63.298 62.759,48.78 52.03,59.509 52.029,59.509 50.797,60.742 48.254,63.285 
-	48.254,63.285 48.234,63.305 48.254,63.326 62.759,77.831 77.277,63.313 77.284,63.305 "/>
-</svg>

package/src/widget/assets/Bitfinex_Icon_Logo.svg

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
-<svg width="800px" height="800px" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
-   <circle cx="512" cy="512" r="512" style="fill:#03ca9b"/>
-   <path d="M732.81 275c-1.67-.73-173.51-24.6-343.39 86.88C284 431.22 270 532.68 274.81 600.36c247.08-27.89 452.41-317.29 458-325.36zM291.57 675.53c21.24 38.14 181.77 124.6 323.87 5.35S745.62 344.66 732.81 275c-4.47 10.11-159.62 356.89-441.24 400.51" style="fill:#fff"/>
-</svg>

package/src/widget/assets/Coinbase_Icon_Logo.svg

@@ -1 +0,0 @@
-<svg width="500" height="500" viewBox="0 0 400 400" xmlns="http://www.w3.org/2000/svg"><path fill="#1652f0" d="m0 0l400 0 0 400-400 0 0-400m168.23 107.38c-24.43 9.85-44.5 29.84-54.56 54.17-7.56 17.87-9.39 37.96-5.94 56.99 4.91 27.2 21.92 51.86 45.41 66.37 17.89 11.27 39.44 16.5 60.5 14.81 23.61-1.56 46.36-12.19 63.08-28.89-10.16-10.4-20.52-20.61-30.81-30.88-12.44 12.02-30.31 18.47-47.55 15.82-12.8-1.69-24.88-8.02-33.6-17.54-11.77-12.48-17.22-30.64-14.2-47.54 1.96-12.42 8.41-24.01 17.75-32.39 12.77-11.76 31.23-17 48.27-13.58 11.09 1.95 21.16 7.72 29.33 15.36 10.31-10.26 20.62-20.52 30.84-30.88-10.58-10.46-23.42-18.68-37.5-23.57-22.82-8.1-48.62-7.47-71.02 1.75"/><path fill="#fff" d="m168.23 107.38c22.4-9.22 48.2-9.85 71.02-1.75 14.08 4.89 26.92 13.11 37.5 23.57-10.22 10.36-20.53 20.62-30.84 30.88-8.17-7.64-18.24-13.41-29.33-15.36-17.04-3.42-35.5 1.82-48.27 13.58-9.34 8.38-15.79 19.97-17.75 32.39-3.02 16.9 2.43 35.06 14.2 47.54 8.72 9.52 20.8 15.85 33.6 17.54 17.24 2.65 35.11-3.8 47.55-15.82 10.29 10.27 20.65 20.48 30.81 30.88-16.72 16.7-39.47 27.33-63.08 28.89-21.06 1.69-42.61-3.54-60.5-14.81-23.49-14.51-40.5-39.17-45.41-66.37-3.45-19.03-1.62-39.12 5.94-56.99 10.06-24.33 30.13-44.32 54.56-54.17"/></svg>