@shapeshiftoss/swap-widget 0.0.2 → 0.2.0

package/src/hooks/useBitcoinSigning.ts

@@ -1,276 +0,0 @@
-import { useAppKitAccount, useAppKitProvider } from '@reown/appkit/react'
-import type { BitcoinConnector } from '@reown/appkit-adapter-bitcoin'
-import { useCallback, useMemo, useState } from 'react'
-
-import { checkBitcoinStatus } from '../services/transactionStatus'
-
-type AccountAddress = string | { address?: string; purpose?: string | number }
-
-type AccountAddressArray = AccountAddress[]
-
-export type SignInput = {
-  address: string
-  index: number
-  sighashTypes?: number[]
-}
-
-type BitcoinConnectorExtended = BitcoinConnector & {
-  getAccountAddresses?: () => Promise<AccountAddressArray> | AccountAddressArray
-  signPSBT?: (params: {
-    psbt: string
-    signInputs: SignInput[]
-    broadcast?: boolean
-  }) => Promise<string | { txid?: string; psbt?: string }>
-  signMessage?: (params: {
-    message: string
-    address: string
-  }) => Promise<string | { signature?: string }>
-}
-
-export type SendTransferParams = {
-  recipientAddress: string
-  amount: string
-  memo?: string
-}
-
-export type SignPsbtParams = {
-  psbt: string
-  signInputs: SignInput[]
-  broadcast?: boolean
-}
-
-export type BitcoinSigningState = {
-  isLoading: boolean
-  error: string | undefined
-  txid: string | undefined
-}
-
-export type UseBitcoinSigningResult = {
-  isConnected: boolean
-  address: string | undefined
-  sendTransfer: (params: SendTransferParams) => Promise<string>
-  signPsbt: (params: SignPsbtParams) => Promise<string>
-  signMessage: (message: string) => Promise<string>
-  getAccountAddresses: () => Promise<string[]>
-  state: BitcoinSigningState
-  reset: () => void
-  checkTxStatus: (
-    txid: string,
-    network?: 'mainnet' | 'testnet',
-  ) => ReturnType<typeof checkBitcoinStatus>
-}
-
-export const useBitcoinSigning = (): UseBitcoinSigningResult => {
-  const { walletProvider } = useAppKitProvider<BitcoinConnector>('bip122')
-  const provider = walletProvider as BitcoinConnectorExtended | undefined
-
-  const [state, setState] = useState<BitcoinSigningState>({
-    isLoading: false,
-    error: undefined,
-    txid: undefined,
-  })
-
-  const {
-    address: appKitBtcAddress,
-    allAccounts: btcAccounts,
-    isConnected: isBtcConnected,
-  } = useAppKitAccount({ namespace: 'bip122' })
-
-  const address = useMemo(() => {
-    if (!provider || !isBtcConnected) return undefined
-    return appKitBtcAddress ?? btcAccounts[0]?.address
-  }, [provider, isBtcConnected, appKitBtcAddress, btcAccounts])
-
-  const sendTransfer = useCallback(
-    async (params: SendTransferParams): Promise<string> => {
-      if (!provider?.sendTransfer) {
-        throw new Error('Bitcoin wallet not connected')
-      }
-
-      setState(prev => ({ ...prev, isLoading: true, error: undefined, txid: undefined }))
-
-      try {
-        const txid = await provider.sendTransfer({
-          recipient: params.recipientAddress,
-          amount: params.amount,
-          ...(params.memo && { memo: params.memo }),
-        })
-
-        if (!txid) {
-          throw new Error('Transaction submitted but no txid returned')
-        }
-
-        setState(prev => ({ ...prev, isLoading: false, txid }))
-        return txid
-      } catch (error) {
-        const errorMessage =
-          error instanceof Error ? error.message : 'Failed to send Bitcoin transfer'
-
-        if (
-          errorMessage.toLowerCase().includes('rejected') ||
-          errorMessage.toLowerCase().includes('denied') ||
-          errorMessage.toLowerCase().includes('cancelled') ||
-          errorMessage.toLowerCase().includes('user refused')
-        ) {
-          setState(prev => ({ ...prev, isLoading: false, error: 'Transaction rejected by user' }))
-          throw new Error('Transaction rejected by user')
-        }
-
-        setState(prev => ({ ...prev, isLoading: false, error: errorMessage }))
-        throw error
-      }
-    },
-    [provider],
-  )
-
-  const signPsbt = useCallback(
-    async (params: SignPsbtParams): Promise<string> => {
-      if (!provider?.signPSBT) {
-        throw new Error('Bitcoin wallet not connected')
-      }
-
-      setState(prev => ({ ...prev, isLoading: true, error: undefined, txid: undefined }))
-
-      try {
-        const result = await provider.signPSBT({
-          psbt: params.psbt,
-          signInputs: params.signInputs,
-          broadcast: params.broadcast ?? true,
-        })
-
-        const txidOrPsbt = typeof result === 'string' ? result : result?.txid ?? result?.psbt ?? ''
-
-        if (params.broadcast !== false) {
-          setState(prev => ({ ...prev, isLoading: false, txid: txidOrPsbt }))
-        } else {
-          setState(prev => ({ ...prev, isLoading: false }))
-        }
-
-        return txidOrPsbt
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Failed to sign PSBT'
-
-        if (
-          errorMessage.toLowerCase().includes('rejected') ||
-          errorMessage.toLowerCase().includes('denied') ||
-          errorMessage.toLowerCase().includes('cancelled') ||
-          errorMessage.toLowerCase().includes('user refused')
-        ) {
-          setState(prev => ({ ...prev, isLoading: false, error: 'Signing rejected by user' }))
-          throw new Error('Signing rejected by user')
-        }
-
-        setState(prev => ({ ...prev, isLoading: false, error: errorMessage }))
-        throw error
-      }
-    },
-    [provider],
-  )
-
-  const signMessage = useCallback(
-    async (message: string): Promise<string> => {
-      if (!provider?.signMessage) {
-        throw new Error('Bitcoin wallet not connected')
-      }
-
-      if (!address) {
-        const errorMessage = 'No Bitcoin address available to sign with'
-        setState(prev => ({ ...prev, isLoading: false, error: errorMessage }))
-        throw new Error(errorMessage)
-      }
-
-      setState(prev => ({ ...prev, isLoading: true, error: undefined }))
-
-      try {
-        const signature = await provider.signMessage({
-          message,
-          address,
-        })
-
-        const signatureObj = signature as string | { signature?: string }
-        const signatureStr =
-          typeof signatureObj === 'string'
-            ? signatureObj
-            : (signatureObj && typeof signatureObj === 'object' && 'signature' in signatureObj
-                ? signatureObj.signature
-                : '') ?? ''
-
-        if (!signatureStr) {
-          throw new Error('Signing succeeded but no signature returned')
-        }
-
-        setState(prev => ({ ...prev, isLoading: false }))
-        return signatureStr
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Failed to sign message'
-        setState(prev => ({ ...prev, isLoading: false, error: errorMessage }))
-        throw error
-      }
-    },
-    [provider, address],
-  )
-
-  const getAccountAddresses = useCallback(async (): Promise<string[]> => {
-    if (!provider) {
-      return []
-    }
-
-    try {
-      const accountsResult = provider.getAccountAddresses?.()
-      const accounts: AccountAddressArray | undefined =
-        accountsResult instanceof Promise
-          ? await accountsResult
-          : (accountsResult as AccountAddressArray | undefined)
-
-      if (!accounts || !Array.isArray(accounts)) return []
-
-      return accounts
-        .map((account: AccountAddress) => {
-          if (typeof account === 'string') return account
-          return account?.address ?? ''
-        })
-        .filter((addr: string | undefined): addr is string => Boolean(addr))
-    } catch {
-      return []
-    }
-  }, [provider])
-
-  const reset = useCallback(() => {
-    setState({
-      isLoading: false,
-      error: undefined,
-      txid: undefined,
-    })
-  }, [])
-
-  const checkTxStatus = useCallback((txid: string, network: 'mainnet' | 'testnet' = 'mainnet') => {
-    return checkBitcoinStatus(txid, network)
-  }, [])
-
-  const isConnected = !!provider && !!address
-
-  return useMemo(
-    () => ({
-      isConnected,
-      address,
-      sendTransfer,
-      signPsbt,
-      signMessage,
-      getAccountAddresses,
-      state,
-      reset,
-      checkTxStatus,
-    }),
-    [
-      isConnected,
-      address,
-      sendTransfer,
-      signPsbt,
-      signMessage,
-      getAccountAddresses,
-      state,
-      reset,
-      checkTxStatus,
-    ],
-  )
-}

package/src/hooks/useMarketData.ts

@@ -1,169 +0,0 @@
-import { adapters } from '@shapeshiftoss/caip'
-import { BigAmount, bn } from '@shapeshiftoss/utils'
-import { useQuery } from '@tanstack/react-query'
-
-import type { AssetId } from '../types'
-
-const MARKET_DATA_STALE_TIME = 10 * 60 * 1000
-const MARKET_DATA_GC_TIME = 60 * 60 * 1000
-
-type MarketData = {
-  price: string
-  marketCap: string
-  volume: string
-  changePercent24Hr: number
-}
-
-export type MarketDataById = Record<AssetId, MarketData>
-
-type CoinGeckoMarketCap = {
-  id: string
-  symbol: string
-  current_price: number
-  market_cap: number
-  total_volume: number
-  price_change_percentage_24h: number
-}
-
-const COINGECKO_PROXY_URL = 'https://api.proxy.shapeshift.com/api/v1/markets'
-const COINGECKO_DIRECT_URL = 'https://api.coingecko.com/api/v3'
-
-const fetchWithRetry = async (url: string, retries = 2, delay = 1000): Promise<Response> => {
-  for (let i = 0; i <= retries; i++) {
-    try {
-      const response = await fetch(url)
-      if (response.ok) return response
-      if (response.status === 429 && i < retries) {
-        await new Promise(r => setTimeout(r, delay * (i + 1)))
-        continue
-      }
-      return response
-    } catch (error) {
-      if (i === retries) throw error
-      await new Promise(r => setTimeout(r, delay * (i + 1)))
-    }
-  }
-  throw new Error('Failed after retries')
-}
-
-const fetchMarketsPage = async (
-  baseUrl: string,
-  page: number,
-  perPage: number,
-): Promise<CoinGeckoMarketCap[]> => {
-  const url = `${baseUrl}/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=${perPage}&page=${page}&sparkline=false`
-  const response = await fetchWithRetry(url)
-  if (!response.ok) return []
-  return response.json()
-}
-
-const fetchAllMarketData = async (): Promise<MarketDataById> => {
-  const result: MarketDataById = {}
-  const perPage = 250
-  const totalPages = 2
-
-  let baseUrl = COINGECKO_PROXY_URL
-
-  const controller = new AbortController()
-  const timeoutId = setTimeout(() => controller.abort(), 5000)
-
-  const testResponse = await fetch(
-    `${COINGECKO_PROXY_URL}/coins/markets?vs_currency=usd&per_page=1&page=1`,
-    { signal: controller.signal },
-  ).catch(() => null)
-
-  clearTimeout(timeoutId)
-
-  if (!testResponse?.ok) {
-    baseUrl = COINGECKO_DIRECT_URL
-  }
-
-  try {
-    const allData: CoinGeckoMarketCap[] = []
-
-    for (let page = 1; page <= totalPages; page++) {
-      const pageData = await fetchMarketsPage(baseUrl, page, perPage)
-      allData.push(...pageData)
-
-      if (page < totalPages) {
-        await new Promise(r => setTimeout(r, 500))
-      }
-    }
-
-    for (const asset of allData) {
-      const assetIds = adapters.coingeckoToAssetIds(asset.id)
-      if (!assetIds?.length) continue
-
-      const marketData: MarketData = {
-        price: asset.current_price?.toString() ?? '0',
-        marketCap: asset.market_cap?.toString() ?? '0',
-        volume: asset.total_volume?.toString() ?? '0',
-        changePercent24Hr: asset.price_change_percentage_24h ?? 0,
-      }
-
-      for (const assetId of assetIds) {
-        result[assetId] = marketData
-      }
-    }
-  } catch (error) {
-    console.error('Failed to fetch market data:', error)
-  }
-
-  return result
-}
-
-export const useAllMarketData = () => {
-  return useQuery({
-    queryKey: ['allMarketData'],
-    queryFn: fetchAllMarketData,
-    staleTime: MARKET_DATA_STALE_TIME,
-    gcTime: MARKET_DATA_GC_TIME,
-    retry: 1,
-    retryDelay: 5000,
-  })
-}
-
-export const useMarketData = (assetIds: AssetId[]) => {
-  const { data: allMarketData, ...rest } = useAllMarketData()
-
-  const filteredData = (() => {
-    if (!allMarketData) return {}
-
-    const result: MarketDataById = {}
-    for (const assetId of assetIds) {
-      if (allMarketData[assetId]) {
-        result[assetId] = allMarketData[assetId]
-      }
-    }
-    return result
-  })()
-
-  return { data: filteredData, ...rest }
-}
-
-export const useAssetPrice = (assetId: AssetId | undefined) => {
-  const { data: allMarketData, ...rest } = useAllMarketData()
-
-  return {
-    data: assetId ? allMarketData?.[assetId]?.price : undefined,
-    ...rest,
-  }
-}
-
-export const formatUsdValue = (
-  cryptoAmount: string,
-  precision: number,
-  usdPrice: string | undefined,
-): string => {
-  if (!usdPrice || usdPrice === '0') return '$0.00'
-
-  const amount = BigAmount.fromBaseUnit({ value: cryptoAmount, precision }).toPrecision()
-  const usdValue = bn(amount).times(usdPrice).toNumber()
-
-  if (usdValue < 0.01) return '< $0.01'
-  if (usdValue < 1000) return `$${usdValue.toFixed(2)}`
-  if (usdValue < 1000000) return `$${(usdValue / 1000).toFixed(2)}K`
-  return `$${(usdValue / 1000000).toFixed(2)}M`
-}
-
-export type { MarketData }

package/src/hooks/useSolanaSigning.ts

@@ -1,275 +0,0 @@
-import { useAppKitProvider } from '@reown/appkit/react'
-import type { Provider } from '@reown/appkit-adapter-solana/react'
-import { useAppKitConnection } from '@reown/appkit-adapter-solana/react'
-import type { Transaction, VersionedTransaction } from '@solana/web3.js'
-import { useCallback, useMemo, useState } from 'react'
-
-import { checkSolanaStatus, waitForSolanaConfirmation } from '../services/transactionStatus'
-
-type AnyTransaction = Transaction | VersionedTransaction
-type TransactionSignature = string | { toString: () => string }
-type MessageSignature = Uint8Array
-
-type SolanaProviderExtended = Provider & {
-  sendTransaction?: (
-    transaction: AnyTransaction,
-    connection: unknown,
-  ) => Promise<TransactionSignature>
-  signTransaction?: <T extends AnyTransaction>(transaction: T) => Promise<T>
-  signMessage?: (message: Uint8Array) => Promise<MessageSignature>
-}
-
-export type SendTransactionParams = {
-  transaction: Transaction | VersionedTransaction
-}
-
-export type SignMessageParams = {
-  message: Uint8Array | string
-}
-
-export type SolanaSigningState = {
-  isLoading: boolean
-  error: string | undefined
-  signature: string | undefined
-}
-
-export type UseSolanaSigningResult = {
-  isConnected: boolean
-  address: string | undefined
-  connection: ReturnType<typeof useAppKitConnection>['connection']
-  sendTransaction: (params: SendTransactionParams) => Promise<string>
-  signMessage: (params: SignMessageParams) => Promise<Uint8Array>
-  signTransaction: <T extends Transaction | VersionedTransaction>(transaction: T) => Promise<T>
-  state: SolanaSigningState
-  reset: () => void
-  checkTxStatus: (signature: string) => ReturnType<typeof checkSolanaStatus>
-  waitForConfirmation: (
-    signature: string,
-    commitment?: 'confirmed' | 'finalized',
-  ) => ReturnType<typeof waitForSolanaConfirmation>
-}
-
-export const useSolanaSigning = (): UseSolanaSigningResult => {
-  const { walletProvider } = useAppKitProvider<Provider>('solana')
-  const provider = walletProvider as SolanaProviderExtended | undefined
-  const { connection } = useAppKitConnection()
-
-  const [state, setState] = useState<SolanaSigningState>({
-    isLoading: false,
-    error: undefined,
-    signature: undefined,
-  })
-
-  const address = useMemo(() => {
-    if (!provider) {
-      return undefined
-    }
-
-    try {
-      const publicKey = provider.publicKey
-      if (!publicKey) {
-        return undefined
-      }
-
-      const addressStr = publicKey?.toBase58?.() ?? publicKey?.toString?.() ?? undefined
-      return addressStr
-    } catch {
-      return undefined
-    }
-  }, [provider])
-
-  const sendTransaction = useCallback(
-    async (params: SendTransactionParams): Promise<string> => {
-      if (!provider?.sendTransaction) {
-        throw new Error('Solana wallet not connected')
-      }
-
-      if (!connection) {
-        throw new Error('Solana connection not available')
-      }
-
-      setState(prev => ({ ...prev, isLoading: true, error: undefined, signature: undefined }))
-
-      try {
-        const signature: TransactionSignature = await provider.sendTransaction(
-          params.transaction,
-          connection,
-        )
-
-        const signatureStr = typeof signature === 'string' ? signature : signature.toString()
-
-        if (!signatureStr) {
-          throw new Error('Transaction submitted but no signature returned')
-        }
-
-        setState(prev => ({ ...prev, isLoading: false, signature: signatureStr }))
-        return signatureStr
-      } catch (error) {
-        const errorMessage =
-          error instanceof Error ? error.message : 'Failed to send Solana transaction'
-
-        if (
-          errorMessage.toLowerCase().includes('rejected') ||
-          errorMessage.toLowerCase().includes('denied') ||
-          errorMessage.toLowerCase().includes('cancelled') ||
-          errorMessage.toLowerCase().includes('user refused') ||
-          errorMessage.toLowerCase().includes('user rejected')
-        ) {
-          setState(prev => ({ ...prev, isLoading: false, error: 'Transaction rejected by user' }))
-          throw new Error('Transaction rejected by user')
-        }
-
-        setState(prev => ({ ...prev, isLoading: false, error: errorMessage }))
-        throw error
-      }
-    },
-    [provider, connection],
-  )
-
-  const signTransaction = useCallback(
-    async <T extends Transaction | VersionedTransaction>(transaction: T): Promise<T> => {
-      if (!provider?.signTransaction) {
-        throw new Error('Solana wallet not connected or does not support signTransaction')
-      }
-
-      setState(prev => ({ ...prev, isLoading: true, error: undefined }))
-
-      try {
-        const signedTransaction = await provider.signTransaction(transaction)
-
-        setState(prev => ({ ...prev, isLoading: false }))
-        return signedTransaction as T
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Failed to sign transaction'
-
-        if (
-          errorMessage.toLowerCase().includes('rejected') ||
-          errorMessage.toLowerCase().includes('denied') ||
-          errorMessage.toLowerCase().includes('cancelled') ||
-          errorMessage.toLowerCase().includes('user refused') ||
-          errorMessage.toLowerCase().includes('user rejected')
-        ) {
-          setState(prev => ({ ...prev, isLoading: false, error: 'Signing rejected by user' }))
-          throw new Error('Signing rejected by user')
-        }
-
-        setState(prev => ({ ...prev, isLoading: false, error: errorMessage }))
-        throw error
-      }
-    },
-    [provider],
-  )
-
-  const signMessage = useCallback(
-    async (params: SignMessageParams): Promise<Uint8Array> => {
-      if (!provider?.signMessage) {
-        throw new Error('Solana wallet not connected or does not support signMessage')
-      }
-
-      setState(prev => ({ ...prev, isLoading: true, error: undefined }))
-
-      try {
-        const messageBytes =
-          typeof params.message === 'string'
-            ? new TextEncoder().encode(params.message)
-            : params.message
-
-        const signature = await provider.signMessage(messageBytes)
-
-        setState(prev => ({ ...prev, isLoading: false }))
-        return signature
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Failed to sign message'
-
-        if (
-          errorMessage.toLowerCase().includes('rejected') ||
-          errorMessage.toLowerCase().includes('denied') ||
-          errorMessage.toLowerCase().includes('cancelled') ||
-          errorMessage.toLowerCase().includes('user refused') ||
-          errorMessage.toLowerCase().includes('user rejected')
-        ) {
-          setState(prev => ({
-            ...prev,
-            isLoading: false,
-            error: 'Message signing rejected by user',
-          }))
-          throw new Error('Message signing rejected by user')
-        }
-
-        setState(prev => ({ ...prev, isLoading: false, error: errorMessage }))
-        throw error
-      }
-    },
-    [provider],
-  )
-
-  const reset = useCallback(() => {
-    setState({
-      isLoading: false,
-      error: undefined,
-      signature: undefined,
-    })
-  }, [])
-
-  const checkTxStatus = useCallback(
-    (signature: string) => {
-      if (!connection) {
-        return Promise.resolve({
-          status: 'pending' as const,
-          error: 'Solana connection not available',
-        })
-      }
-      return checkSolanaStatus(
-        signature,
-        connection as unknown as Parameters<typeof checkSolanaStatus>[1],
-      )
-    },
-    [connection],
-  )
-
-  const waitForConfirmation = useCallback(
-    (signature: string, commitment: 'confirmed' | 'finalized' = 'confirmed') => {
-      if (!connection) {
-        return Promise.resolve({
-          status: 'failed' as const,
-          error: 'Solana connection not available',
-        })
-      }
-      return waitForSolanaConfirmation(
-        signature,
-        connection as unknown as Parameters<typeof waitForSolanaConfirmation>[1],
-        commitment,
-      )
-    },
-    [connection],
-  )
-
-  const actuallyConnected = !!address && !!connection
-
-  return useMemo(
-    () => ({
-      isConnected: actuallyConnected,
-      address,
-      connection,
-      sendTransaction,
-      signTransaction,
-      signMessage,
-      state,
-      reset,
-      checkTxStatus,
-      waitForConfirmation,
-    }),
-    [
-      actuallyConnected,
-      address,
-      connection,
-      sendTransaction,
-      signTransaction,
-      signMessage,
-      state,
-      reset,
-      checkTxStatus,
-      waitForConfirmation,
-    ],
-  )
-}