@shapeshiftoss/swap-widget 0.0.2 → 0.2.0

package/src/types/index.ts

@@ -1,361 +0,0 @@
-import type { BitcoinConnector } from '@reown/appkit-adapter-bitcoin'
-import type { Provider as SolanaProvider } from '@reown/appkit-adapter-solana/react'
-import type { AssetId, ChainId } from '@shapeshiftoss/caip'
-import {
-  arbitrumChainId,
-  avalancheChainId,
-  baseChainId,
-  bchChainId,
-  bscChainId,
-  btcChainId,
-  CHAIN_NAMESPACE,
-  cosmosChainId,
-  dogeChainId,
-  ethChainId,
-  fromChainId,
-  gnosisChainId,
-  hyperEvmChainId,
-  katanaChainId,
-  ltcChainId,
-  mayachainChainId,
-  monadChainId,
-  optimismChainId,
-  plasmaChainId,
-  polygonChainId,
-  solanaChainId,
-  thorchainChainId,
-  worldChainChainId,
-} from '@shapeshiftoss/caip'
-import type { TransactionData } from '@shapeshiftoss/types'
-import { BigAmount } from '@shapeshiftoss/utils'
-import type { WalletClient } from 'viem'
-import { erc20Abi } from 'viem'
-
-export type { AssetId, ChainId }
-export type { BitcoinConnector }
-export type { SolanaProvider }
-
-export enum SwapperName {
-  Thorchain = 'THORChain',
-  Mayachain = 'MAYAChain',
-  CowSwap = 'CoW Swap',
-  Zrx = '0x',
-  ArbitrumBridge = 'Arbitrum Bridge',
-  Portals = 'Portals',
-  Chainflip = 'Chainflip',
-  Jupiter = 'Jupiter',
-  Relay = 'Relay',
-  ButterSwap = 'ButterSwap',
-  Bebop = 'Bebop',
-  NearIntents = 'NEAR Intents',
-  Cetus = 'Cetus',
-  Sunio = 'Sun.io',
-  Avnu = 'AVNU',
-}
-
-export type Chain = {
-  chainId: ChainId
-  name: string
-  icon: string
-  color: string
-  nativeAssetId: AssetId
-}
-
-export type Asset = {
-  assetId: AssetId
-  chainId: ChainId
-  symbol: string
-  name: string
-  precision: number
-  icon?: string
-  color?: string
-  networkName?: string
-  networkIcon?: string
-  explorer?: string
-  explorerTxLink?: string
-  explorerAddressLink?: string
-  relatedAssetKey?: AssetId | null
-}
-
-export type TradeQuoteStep = {
-  sellAsset: Asset
-  buyAsset: Asset
-  sellAmountCryptoBaseUnit: string
-  buyAmountCryptoBaseUnit: string
-  rate: string
-  source: SwapperName
-  feeData: {
-    networkFeeCryptoBaseUnit: string
-    protocolFees?: Record<AssetId, { amountCryptoBaseUnit: string }>
-  }
-  allowanceContract?: string
-  estimatedExecutionTimeMs?: number
-}
-
-export type TradeQuote = {
-  id: string
-  rate: string
-  swapperName: SwapperName
-  steps: TradeQuoteStep[]
-  receiveAddress: string
-  affiliateBps: string
-  slippageTolerancePercentageDecimal?: string
-  isStreaming?: boolean
-}
-
-export type TradeRate = {
-  swapperName: SwapperName
-  rate: string
-  buyAmountCryptoBaseUnit: string
-  sellAmountCryptoBaseUnit: string
-  steps: number
-  estimatedExecutionTimeMs?: number
-  affiliateBps: string
-  networkFeeCryptoBaseUnit?: string
-  error?: {
-    code: string
-    message: string
-  }
-  id?: string
-}
-
-export type ThemeMode = 'light' | 'dark'
-
-export type ThemeConfig = {
-  mode: ThemeMode
-  accentColor?: string
-  backgroundColor?: string
-  cardColor?: string
-  textColor?: string
-  borderRadius?: string
-  fontFamily?: string
-  borderColor?: string
-  secondaryTextColor?: string
-  mutedTextColor?: string
-  inputColor?: string
-  hoverColor?: string
-  buttonVariant?: 'filled' | 'outline'
-}
-
-export type SwapWidgetProps = {
-  affiliateAddress?: string
-  apiBaseUrl?: string
-  defaultSellAsset?: Asset
-  defaultBuyAsset?: Asset
-  disabledChainIds?: ChainId[]
-  disabledAssetIds?: AssetId[]
-  allowedChainIds?: ChainId[]
-  sellDisabledChainIds?: ChainId[]
-  buyDisabledChainIds?: ChainId[]
-  sellDisabledAssetIds?: AssetId[]
-  buyDisabledAssetIds?: AssetId[]
-  sellAllowedChainIds?: ChainId[]
-  buyAllowedChainIds?: ChainId[]
-  sellAllowedAssetIds?: AssetId[]
-  buyAllowedAssetIds?: AssetId[]
-  allowedSwapperNames?: SwapperName[]
-  walletClient?: WalletClient
-  onConnectWallet?: () => void
-  onSwapSuccess?: (txHash: string) => void
-  onSwapError?: (error: Error) => void
-  onAssetSelect?: (type: 'sell' | 'buy', asset: Asset) => void
-  theme?: ThemeMode | ThemeConfig
-  defaultSlippage?: string
-  showPoweredBy?: boolean
-  enableWalletConnection?: boolean
-  walletConnectProjectId?: string
-  defaultReceiveAddress?: string
-  ratesRefetchInterval?: number
-  isBuyAssetLocked?: boolean
-}
-
-export type RatesResponse = {
-  rates: TradeRate[]
-}
-
-export type {
-  CosmosTransactionData,
-  EvmTransactionData,
-  Permit2SignatureRequired,
-  SolanaTransactionData,
-  TransactionData,
-  UtxoDepositTransactionData,
-  UtxoPsbtTransactionData,
-  UtxoTransactionData,
-} from '@shapeshiftoss/types'
-
-export type ApiQuoteStep = {
-  sellAsset: Asset
-  buyAsset: Asset
-  sellAmountCryptoBaseUnit: string
-  buyAmountAfterFeesCryptoBaseUnit: string
-  allowanceContract: string
-  estimatedExecutionTimeMs: number | undefined
-  source: string
-  transactionData?: TransactionData
-  relayTransactionMetadata?: TransactionData
-  butterSwapTransactionMetadata?: TransactionData
-  solanaTransactionMetadata?: {
-    instructions: {
-      programId: string
-      keys: { pubkey: string; isSigner: boolean; isWritable: boolean }[]
-      data: { data: number[] }
-    }[]
-  }
-}
-
-export type ApprovalInfo = {
-  isRequired: boolean
-  spender: string
-  approvalTx?: {
-    to: string
-    data: string
-    value: string
-  }
-}
-
-export type QuoteResponse = {
-  quoteId: string
-  swapperName: SwapperName
-  rate: string
-  sellAsset: Asset
-  buyAsset: Asset
-  sellAmountCryptoBaseUnit: string
-  buyAmountBeforeFeesCryptoBaseUnit: string
-  buyAmountAfterFeesCryptoBaseUnit: string
-  affiliateBps: string
-  slippageTolerancePercentageDecimal: string | undefined
-  networkFeeCryptoBaseUnit: string | undefined
-  /** @deprecated Use `quote.steps` instead. Top-level `steps` is kept for backward compatibility. */
-  steps: ApiQuoteStep[]
-  approval: ApprovalInfo
-  expiresAt: number
-  transactionData?: TransactionData
-  quote?: {
-    steps?: ApiQuoteStep[]
-  }
-}
-
-export { erc20Abi as ERC20_ABI }
-
-export type AssetsResponse = {
-  byId: Record<AssetId, Asset>
-  ids: AssetId[]
-}
-
-export const EVM_CHAIN_IDS = {
-  ethereum: ethChainId,
-  arbitrum: arbitrumChainId,
-  optimism: optimismChainId,
-  polygon: polygonChainId,
-  base: baseChainId,
-  avalanche: avalancheChainId,
-  bsc: bscChainId,
-  gnosis: gnosisChainId,
-  monad: monadChainId,
-  hyperEvm: hyperEvmChainId,
-  plasma: plasmaChainId,
-  worldChain: worldChainChainId,
-  katana: katanaChainId,
-} as const
-
-export const UTXO_CHAIN_IDS = {
-  bitcoin: btcChainId,
-  bitcoinCash: bchChainId,
-  dogecoin: dogeChainId,
-  litecoin: ltcChainId,
-} as const
-
-export const COSMOS_CHAIN_IDS = {
-  cosmos: cosmosChainId,
-  thorchain: thorchainChainId,
-  mayachain: mayachainChainId,
-} as const
-
-export const OTHER_CHAIN_IDS = {
-  solana: solanaChainId,
-} as const
-
-export const isEvmChainId = (chainId: string): boolean => {
-  const { chainNamespace } = fromChainId(chainId as ChainId)
-  return chainNamespace === CHAIN_NAMESPACE.Evm
-}
-
-export const getEvmNetworkId = (chainId: string): number => {
-  const { chainReference } = fromChainId(chainId as ChainId)
-  return parseInt(chainReference, 10)
-}
-
-export const getChainType = (chainId: string): 'evm' | 'utxo' | 'cosmos' | 'solana' | 'other' => {
-  const { chainNamespace } = fromChainId(chainId as ChainId)
-  switch (chainNamespace) {
-    case CHAIN_NAMESPACE.Evm:
-      return 'evm'
-    case CHAIN_NAMESPACE.Utxo:
-      return 'utxo'
-    case CHAIN_NAMESPACE.CosmosSdk:
-      return 'cosmos'
-    case CHAIN_NAMESPACE.Solana:
-      return 'solana'
-    default:
-      return 'other'
-  }
-}
-
-export const formatAmount = (amount: string, decimals: number, maxDecimals?: number): string => {
-  const effectiveMaxDecimals = maxDecimals ?? Math.min(decimals, 8)
-  const result = BigAmount.fromBaseUnit({ value: amount, precision: decimals }).toFixed(
-    effectiveMaxDecimals,
-  )
-  const num = Number(result)
-  if (num === 0) return '0'
-
-  const threshold = Math.pow(10, -effectiveMaxDecimals)
-  if (num > 0 && num < threshold) {
-    return `< ${threshold.toFixed(effectiveMaxDecimals)}`
-  }
-
-  return num.toLocaleString(undefined, {
-    maximumFractionDigits: effectiveMaxDecimals,
-    minimumFractionDigits: 0,
-  })
-}
-
-export const parseAmount = (amount: string, decimals: number): string => {
-  return BigAmount.fromPrecision({ value: amount, precision: decimals }).toBaseUnit()
-}
-
-export const truncateAddress = (address: string, chars = 4): string => {
-  if (address.length <= chars * 2 + 2) return address
-  return `${address.slice(0, chars + 2)}...${address.slice(-chars)}`
-}
-
-export type TransactionStatus = 'pending' | 'confirmed' | 'failed'
-
-export type TransactionStatusResult = {
-  status: TransactionStatus
-  confirmations?: number
-  blockNumber?: number
-  error?: string
-}
-
-export type BitcoinTransactionStatus = {
-  confirmed: boolean
-  block_height?: number
-  block_hash?: string
-  block_time?: number
-}
-
-export type WalletProviderNamespace = 'eip155' | 'bip122' | 'solana'
-
-export type MultiChainAddress = {
-  namespace: WalletProviderNamespace
-  address: string
-  chainId?: ChainId
-}
-
-export type MultiChainWalletState = {
-  isConnected: boolean
-  addresses: MultiChainAddress[]
-  activeNamespace?: WalletProviderNamespace
-}

package/src/utils/addressValidation.ts

@@ -1,201 +0,0 @@
-import { bech32 } from 'bech32'
-import { isAddress } from 'viem'
-
-import type { ChainId } from '../types'
-import { COSMOS_CHAIN_IDS, getChainType } from '../types'
-
-/**
- * Validates a Bitcoin address (Legacy, SegWit, Native SegWit, Taproot)
- */
-export const isValidBitcoinAddress = (address: string): boolean => {
-  // Legacy (P2PKH) - starts with 1
-  const legacyRegex = /^1[a-km-zA-HJ-NP-Z1-9]{25,34}$/
-  // Legacy (P2SH) - starts with 3
-  const p2shRegex = /^3[a-km-zA-HJ-NP-Z1-9]{25,34}$/
-  // Native SegWit (Bech32) - starts with bc1q
-  const nativeSegwitRegex = /^bc1q[a-z0-9]{38,58}$/i
-  // Taproot (Bech32m) - starts with bc1p
-  const taprootRegex = /^bc1p[a-z0-9]{58}$/i
-
-  return (
-    legacyRegex.test(address) ||
-    p2shRegex.test(address) ||
-    nativeSegwitRegex.test(address) ||
-    taprootRegex.test(address)
-  )
-}
-
-/**
- * Validates a Bitcoin Cash address
- */
-export const isValidBitcoinCashAddress = (address: string): boolean => {
-  // CashAddr format - starts with bitcoincash: or just q/p
-  const cashAddrRegex = /^(bitcoincash:)?[qp][a-z0-9]{41}$/i
-  // Legacy format (same as Bitcoin)
-  const legacyRegex = /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/
-
-  return cashAddrRegex.test(address) || legacyRegex.test(address)
-}
-
-/**
- * Validates a Litecoin address
- */
-export const isValidLitecoinAddress = (address: string): boolean => {
-  // Legacy (P2PKH) - starts with L
-  const legacyRegex = /^L[a-km-zA-HJ-NP-Z1-9]{25,34}$/
-  // Legacy (P2SH) - starts with M or 3
-  const p2shRegex = /^[M3][a-km-zA-HJ-NP-Z1-9]{25,34}$/
-  // Native SegWit (Bech32) - starts with ltc1
-  const nativeSegwitRegex = /^ltc1[a-z0-9]{38,58}$/i
-
-  return legacyRegex.test(address) || p2shRegex.test(address) || nativeSegwitRegex.test(address)
-}
-
-/**
- * Validates a Dogecoin address
- */
-export const isValidDogecoinAddress = (address: string): boolean => {
-  // P2PKH - starts with D
-  const p2pkhRegex = /^D[5-9A-HJ-NP-U][a-km-zA-HJ-NP-Z1-9]{32}$/
-  // P2SH - starts with 9 or A
-  const p2shRegex = /^[9A][a-km-zA-HJ-NP-Z1-9]{33}$/
-
-  return p2pkhRegex.test(address) || p2shRegex.test(address)
-}
-
-export const isValidCosmosAddress = (address: string, expectedPrefix?: string): boolean => {
-  try {
-    const decoded = bech32.decode(address)
-    if (expectedPrefix && decoded.prefix !== expectedPrefix) {
-      return false
-    }
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Gets the expected bech32 prefix for a Cosmos chain
- */
-const getCosmosPrefix = (chainId: ChainId): string | undefined => {
-  const prefixMap: Record<string, string> = {
-    [COSMOS_CHAIN_IDS.cosmos]: 'cosmos',
-    [COSMOS_CHAIN_IDS.thorchain]: 'thor',
-    [COSMOS_CHAIN_IDS.mayachain]: 'maya',
-  }
-  return prefixMap[chainId]
-}
-
-/**
- * Validates a Solana address (base58, 32-44 chars)
- */
-export const isValidSolanaAddress = (address: string): boolean => {
-  // Solana addresses are base58 encoded, typically 32-44 characters
-  // Base58 alphabet excludes 0, O, I, l
-  const base58Regex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/
-  return base58Regex.test(address)
-}
-
-/**
- * Validates an address for a specific chain
- */
-export const validateAddress = (
-  address: string,
-  chainId: ChainId,
-): { valid: boolean; error?: string } => {
-  if (!address || address.trim() === '') {
-    return { valid: false, error: 'Address is required' }
-  }
-
-  const trimmedAddress = address.trim()
-  const chainType = getChainType(chainId)
-
-  switch (chainType) {
-    case 'evm':
-      if (!isAddress(trimmedAddress, { strict: false })) {
-        return { valid: false, error: 'Invalid EVM address' }
-      }
-      break
-
-    case 'utxo':
-      // Determine specific UTXO chain
-      if (chainId.includes('000000000019d6689c085ae165831e93')) {
-        // Bitcoin
-        if (!isValidBitcoinAddress(trimmedAddress)) {
-          return { valid: false, error: 'Invalid Bitcoin address' }
-        }
-      } else if (chainId.includes('000000000000000000651ef99cb9fcbe')) {
-        // Bitcoin Cash
-        if (!isValidBitcoinCashAddress(trimmedAddress)) {
-          return { valid: false, error: 'Invalid Bitcoin Cash address' }
-        }
-      } else if (chainId.includes('12a765e31ffd4059bada1e25190f6e98')) {
-        // Litecoin
-        if (!isValidLitecoinAddress(trimmedAddress)) {
-          return { valid: false, error: 'Invalid Litecoin address' }
-        }
-      } else if (chainId.includes('00000000001a91e3dace36e2be3bf030')) {
-        // Dogecoin
-        if (!isValidDogecoinAddress(trimmedAddress)) {
-          return { valid: false, error: 'Invalid Dogecoin address' }
-        }
-      } else {
-        return { valid: false, error: 'Unsupported UTXO chain' }
-      }
-      break
-
-    case 'cosmos': {
-      const expectedPrefix = getCosmosPrefix(chainId)
-      if (!isValidCosmosAddress(trimmedAddress, expectedPrefix)) {
-        const chainName = expectedPrefix
-          ? expectedPrefix.charAt(0).toUpperCase() + expectedPrefix.slice(1)
-          : 'Cosmos'
-        return { valid: false, error: `Invalid ${chainName} address` }
-      }
-      break
-    }
-
-    case 'solana':
-      if (!isValidSolanaAddress(trimmedAddress)) {
-        return { valid: false, error: 'Invalid Solana address' }
-      }
-      break
-
-    default:
-      return { valid: false, error: 'Unsupported chain type' }
-  }
-
-  return { valid: true }
-}
-
-/**
- * Gets the expected address format hint for a chain
- */
-export const getAddressFormatHint = (chainId: ChainId): string => {
-  const chainType = getChainType(chainId)
-
-  switch (chainType) {
-    case 'evm':
-      return '0x...'
-    case 'utxo':
-      if (chainId.includes('000000000019d6689c085ae165831e93')) {
-        return 'bc1... or 1... or 3...'
-      } else if (chainId.includes('000000000000000000651ef99cb9fcbe')) {
-        return 'bitcoincash:q... or 1...'
-      } else if (chainId.includes('12a765e31ffd4059bada1e25190f6e98')) {
-        return 'ltc1... or L... or M...'
-      } else if (chainId.includes('00000000001a91e3dace36e2be3bf030')) {
-        return 'D...'
-      }
-      return 'Enter address'
-    case 'cosmos': {
-      const prefix = getCosmosPrefix(chainId)
-      return prefix ? `${prefix}1...` : 'Enter address'
-    }
-    case 'solana':
-      return 'Enter Solana address'
-    default:
-      return 'Enter address'
-  }
-}

package/src/utils/redirect.ts

@@ -1,45 +0,0 @@
-import type { Asset, AssetId } from '../types'
-import { isEvmChainId } from '../types'
-
-const SHAPESHIFT_APP_URL = 'https://app.shapeshift.com'
-
-export type RedirectParams = {
-  sellAssetId: AssetId
-  buyAssetId: AssetId
-  sellAmount?: string
-}
-
-export const buildShapeShiftTradeUrl = (params: RedirectParams): string => {
-  const url = new URL(`${SHAPESHIFT_APP_URL}/trade`)
-  url.searchParams.set('sellAssetId', params.sellAssetId)
-  url.searchParams.set('buyAssetId', params.buyAssetId)
-  if (params.sellAmount) {
-    url.searchParams.set('sellAmount', params.sellAmount)
-  }
-  return url.toString()
-}
-
-export const redirectToShapeShift = (params: RedirectParams): void => {
-  const url = buildShapeShiftTradeUrl(params)
-  window.open(url, '_blank', 'noopener,noreferrer')
-}
-
-export type ChainType = 'evm' | 'utxo' | 'cosmos' | 'solana' | 'other'
-
-export const getChainTypeFromAsset = (asset: Asset): ChainType => {
-  const chainId = asset.chainId
-
-  if (isEvmChainId(chainId)) return 'evm'
-  if (chainId.startsWith('bip122:')) return 'utxo'
-  if (chainId.startsWith('cosmos:')) return 'cosmos'
-  if (chainId.startsWith('solana:')) return 'solana'
-
-  return 'other'
-}
-
-export const canExecuteInWidget = (sellAsset: Asset, buyAsset: Asset): boolean => {
-  const sellChainType = getChainTypeFromAsset(sellAsset)
-  const buyChainType = getChainTypeFromAsset(buyAsset)
-
-  return sellChainType === 'evm' && buyChainType === 'evm'
-}

package/src/vite-env.d.ts

@@ -1,10 +0,0 @@
-/// <reference types="vite/client" />
-
-interface EthereumProvider {
-  request: (args: { method: string; params?: unknown[] }) => Promise<unknown>
-  on: (event: string, callback: (accounts: string[]) => void) => void
-}
-
-interface Window {
-  ethereum?: EthereumProvider
-}

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-    "jsx": "react-jsx",
-
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "include": ["src"],
-  "references": [{ "path": "./tsconfig.node.json" }]
-}

package/tsconfig.node.json

@@ -1,10 +0,0 @@
-{
-  "compilerOptions": {
-    "composite": true,
-    "skipLibCheck": true,
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["vite.config.ts"]
-}