@shapeshiftoss/swap-widget 0.0.2 → 0.2.0

package/src/machines/guards.ts

@@ -1,33 +0,0 @@
-import type { SwapMachineContext } from './types'
-
-export const hasValidInput = (context: SwapMachineContext): boolean => {
-  return (
-    !!context.sellAsset &&
-    !!context.buyAsset &&
-    !!context.sellAmountBaseUnit &&
-    context.sellAmountBaseUnit !== '0'
-  )
-}
-
-export const hasQuote = (context: SwapMachineContext): boolean => context.quote !== null
-
-export const isApprovalRequired = (context: SwapMachineContext): boolean => {
-  if (context.quote?.approval?.isRequired !== true || context.chainType !== 'evm') return false
-  const assetIdParts = context.sellAsset.assetId.split('/')
-  const namespace = assetIdParts[1]?.split(':')[0]
-  return namespace === 'erc20'
-}
-
-export const canRetry = (context: SwapMachineContext): boolean => context.retryCount < 3
-
-export const isEvmChain = (context: SwapMachineContext): boolean => context.chainType === 'evm'
-
-export const isUtxoChain = (context: SwapMachineContext): boolean => context.chainType === 'utxo'
-
-export const isSolanaChain = (context: SwapMachineContext): boolean =>
-  context.chainType === 'solana'
-
-export const hasWallet = (context: SwapMachineContext): boolean => !!context.walletAddress
-
-export const hasReceiveAddress = (context: SwapMachineContext): boolean =>
-  !!context.effectiveReceiveAddress

package/src/machines/swapMachine.ts

@@ -1,288 +0,0 @@
-import { assign, setup } from 'xstate'
-
-import { DEFAULT_BUY_ASSET, DEFAULT_SELL_ASSET } from '../constants/defaults'
-import type { Asset, QuoteResponse, TradeRate } from '../types'
-import { getChainType, parseAmount } from '../types'
-import * as guardFns from './guards'
-import type { SwapMachineContext, SwapMachineEvent } from './types'
-
-export const createInitialContext = (input?: {
-  sellAsset?: Asset
-  buyAsset?: Asset
-  slippage?: string
-}): SwapMachineContext => {
-  const sellAsset = input?.sellAsset ?? DEFAULT_SELL_ASSET
-  const buyAsset = input?.buyAsset ?? DEFAULT_BUY_ASSET
-  const sellChainType = getChainType(sellAsset.chainId)
-  const buyChainType = getChainType(buyAsset.chainId)
-
-  return {
-    sellAsset,
-    buyAsset,
-    sellAmount: '',
-    sellAmountBaseUnit: undefined,
-    selectedRate: null,
-    quote: null,
-    txHash: null,
-    approvalTxHash: null,
-    error: null,
-    errorSource: null,
-    retryCount: 0,
-    chainType: sellChainType,
-    slippage: input?.slippage ?? '0.5',
-    walletAddress: undefined,
-    effectiveReceiveAddress: '',
-    isSellAssetEvm: sellChainType === 'evm',
-    isSellAssetUtxo: sellChainType === 'utxo',
-    isSellAssetSolana: sellChainType === 'solana',
-    isBuyAssetEvm: buyChainType === 'evm',
-  }
-}
-
-export const swapMachine = setup({
-  types: {
-    context: {} as SwapMachineContext,
-    events: {} as SwapMachineEvent,
-  },
-  guards: {
-    hasValidInput: ({ context }) => guardFns.hasValidInput(context),
-    isApprovalRequired: ({ context, event }) => {
-      const quote = (event as { type: 'QUOTE_SUCCESS'; quote: QuoteResponse }).quote
-      if (quote?.approval?.isRequired !== true || context.chainType !== 'evm') return false
-      const namespace = context.sellAsset.assetId.split('/')[1]?.split(':')[0]
-      return namespace === 'erc20'
-    },
-    canRetry: ({ context }) => guardFns.canRetry(context),
-    isQuoteError: ({ context }) => context.errorSource === 'QUOTE_ERROR',
-    isApprovalError: ({ context }) => context.errorSource === 'APPROVAL_ERROR',
-    isStatusFailed: ({ context }) => context.errorSource === 'STATUS_FAILED',
-    hasQuote: ({ context }) => guardFns.hasQuote(context),
-    isEvmChain: ({ context }) => guardFns.isEvmChain(context),
-    isUtxoChain: ({ context }) => guardFns.isUtxoChain(context),
-    isSolanaChain: ({ context }) => guardFns.isSolanaChain(context),
-    hasWallet: ({ context }) => guardFns.hasWallet(context),
-    hasReceiveAddress: ({ context }) => guardFns.hasReceiveAddress(context),
-  },
-  actions: {
-    assignSellAsset: assign(({ context, event }) => {
-      const { asset } = event as { type: 'SET_SELL_ASSET'; asset: Asset }
-      const chainType = getChainType(asset.chainId)
-      return {
-        sellAsset: asset,
-        sellAmountBaseUnit: context.sellAmount
-          ? parseAmount(context.sellAmount, asset.precision)
-          : undefined,
-        chainType,
-        isSellAssetEvm: chainType === 'evm',
-        isSellAssetUtxo: chainType === 'utxo',
-        isSellAssetSolana: chainType === 'solana',
-        selectedRate: null,
-        quote: null,
-      }
-    }),
-    assignBuyAsset: assign(({ event }) => {
-      const { asset } = event as { type: 'SET_BUY_ASSET'; asset: Asset }
-      const buyChainType = getChainType(asset.chainId)
-      return {
-        buyAsset: asset,
-        isBuyAssetEvm: buyChainType === 'evm',
-        selectedRate: null,
-        quote: null,
-      }
-    }),
-    assignSellAmount: assign(({ event }) => {
-      const { amount, amountBaseUnit } = event as {
-        type: 'SET_SELL_AMOUNT'
-        amount: string
-        amountBaseUnit: string | undefined
-      }
-      return {
-        sellAmount: amount,
-        sellAmountBaseUnit: amountBaseUnit,
-      }
-    }),
-    assignSlippage: assign(({ event }) => ({
-      slippage: (event as { type: 'SET_SLIPPAGE'; slippage: string }).slippage,
-    })),
-    assignSelectedRate: assign(({ event }) => ({
-      selectedRate: (event as { type: 'SELECT_RATE'; rate: TradeRate }).rate,
-    })),
-    assignQuote: assign(({ event }) => ({
-      quote: (event as { type: 'QUOTE_SUCCESS'; quote: QuoteResponse }).quote,
-    })),
-    assignQuoteError: assign(({ event }) => ({
-      error: (event as { type: 'QUOTE_ERROR'; error: string }).error,
-      errorSource: 'QUOTE_ERROR' as const,
-    })),
-    assignApprovalTxHash: assign(({ event }) => ({
-      approvalTxHash: (event as { type: 'APPROVAL_SUCCESS'; txHash: string }).txHash,
-    })),
-    assignApprovalError: assign(({ event }) => ({
-      error: (event as { type: 'APPROVAL_ERROR'; error: string }).error,
-      errorSource: 'APPROVAL_ERROR' as const,
-    })),
-    assignTxHash: assign(({ event }) => ({
-      txHash: (event as { type: 'EXECUTE_SUCCESS'; txHash: string }).txHash,
-    })),
-    assignExecuteError: assign(({ event }) => ({
-      error: (event as { type: 'EXECUTE_ERROR'; error: string }).error,
-      errorSource: 'EXECUTE_ERROR' as const,
-    })),
-    assignStatusFailed: assign(({ event }) => ({
-      error: (event as { type: 'STATUS_FAILED'; error: string }).error,
-      errorSource: 'STATUS_FAILED' as const,
-    })),
-    assignWalletAddress: assign(({ event }) => ({
-      walletAddress: (event as { type: 'SET_WALLET_ADDRESS'; address: string | undefined }).address,
-    })),
-    assignReceiveAddress: assign(({ event }) => ({
-      effectiveReceiveAddress: (event as { type: 'SET_RECEIVE_ADDRESS'; address: string }).address,
-    })),
-    assignChainInfo: assign(({ event }) => {
-      const e = event as Extract<SwapMachineEvent, { type: 'UPDATE_CHAIN_INFO' }>
-      return {
-        chainType: e.chainType,
-        isSellAssetEvm: e.isSellAssetEvm,
-        isSellAssetUtxo: e.isSellAssetUtxo,
-        isSellAssetSolana: e.isSellAssetSolana,
-        isBuyAssetEvm: e.isBuyAssetEvm,
-      }
-    }),
-    incrementRetryCount: assign(({ context }) => ({
-      retryCount: context.retryCount + 1,
-      error: null,
-      errorSource: null,
-    })),
-    resetSwapState: assign(({ context }) => ({
-      quote: null,
-      txHash: null,
-      approvalTxHash: null,
-      error: null,
-      errorSource: null,
-      retryCount: 0,
-      selectedRate: null,
-      sellAsset: context.sellAsset,
-      buyAsset: context.buyAsset,
-      sellAmount: context.sellAmount,
-      sellAmountBaseUnit: context.sellAmountBaseUnit,
-      slippage: context.slippage,
-      walletAddress: context.walletAddress,
-      effectiveReceiveAddress: context.effectiveReceiveAddress,
-    })),
-  },
-}).createMachine({
-  id: 'swap',
-  initial: 'idle',
-  context: createInitialContext(),
-  states: {
-    idle: {
-      always: { target: 'input' },
-    },
-    input: {
-      on: {
-        SET_SELL_ASSET: { actions: 'assignSellAsset' },
-        SET_BUY_ASSET: { actions: 'assignBuyAsset' },
-        SET_SELL_AMOUNT: { actions: 'assignSellAmount' },
-        SET_SLIPPAGE: { actions: 'assignSlippage' },
-        SELECT_RATE: { actions: 'assignSelectedRate' },
-        SET_WALLET_ADDRESS: { actions: 'assignWalletAddress' },
-        SET_RECEIVE_ADDRESS: { actions: 'assignReceiveAddress' },
-        UPDATE_CHAIN_INFO: { actions: 'assignChainInfo' },
-        FETCH_QUOTE: {
-          target: 'quoting',
-          guard: 'hasValidInput',
-        },
-      },
-    },
-    quoting: {
-      on: {
-        QUOTE_SUCCESS: [
-          {
-            target: 'approval_needed',
-            guard: 'isApprovalRequired',
-            actions: 'assignQuote',
-          },
-          {
-            target: 'executing',
-            actions: 'assignQuote',
-          },
-        ],
-        QUOTE_ERROR: {
-          target: 'error',
-          actions: 'assignQuoteError',
-        },
-      },
-    },
-    approval_needed: {
-      on: {
-        APPROVE: { target: 'approving' },
-        RESET: { target: 'input', actions: 'resetSwapState' },
-      },
-    },
-    approving: {
-      on: {
-        APPROVAL_SUCCESS: {
-          target: 'executing',
-          actions: 'assignApprovalTxHash',
-        },
-        APPROVAL_ERROR: {
-          target: 'error',
-          actions: 'assignApprovalError',
-        },
-      },
-    },
-    executing: {
-      on: {
-        EXECUTE_SUCCESS: {
-          target: 'polling_status',
-          actions: 'assignTxHash',
-        },
-        EXECUTE_ERROR: {
-          target: 'error',
-          actions: 'assignExecuteError',
-        },
-      },
-    },
-    polling_status: {
-      on: {
-        STATUS_CONFIRMED: { target: 'complete' },
-        STATUS_FAILED: {
-          target: 'error',
-          actions: 'assignStatusFailed',
-        },
-      },
-    },
-    complete: {
-      on: {
-        RESET: { target: 'input', actions: 'resetSwapState' },
-      },
-    },
-    error: {
-      on: {
-        RETRY: [
-          {
-            target: 'quoting',
-            guard: { type: 'isQuoteError' },
-            actions: 'incrementRetryCount',
-          },
-          {
-            target: 'approving',
-            guard: { type: 'isApprovalError' },
-            actions: 'incrementRetryCount',
-          },
-          {
-            target: 'quoting',
-            guard: { type: 'isStatusFailed' },
-            actions: 'incrementRetryCount',
-          },
-          {
-            target: 'executing',
-            guard: { type: 'canRetry' },
-            actions: 'incrementRetryCount',
-          },
-        ],
-        RESET: { target: 'input', actions: 'resetSwapState' },
-      },
-    },
-  },
-})

package/src/machines/types.ts

@@ -1,54 +0,0 @@
-import type { Asset, QuoteResponse, TradeRate } from '../types'
-
-export type ErrorSource = 'QUOTE_ERROR' | 'APPROVAL_ERROR' | 'EXECUTE_ERROR' | 'STATUS_FAILED'
-
-export type SwapMachineContext = {
-  sellAsset: Asset
-  buyAsset: Asset
-  sellAmount: string
-  sellAmountBaseUnit: string | undefined
-  selectedRate: TradeRate | null
-  quote: QuoteResponse | null
-  txHash: string | null
-  approvalTxHash: string | null
-  error: string | null
-  errorSource: ErrorSource | null
-  retryCount: number
-  chainType: 'evm' | 'utxo' | 'solana' | 'cosmos' | 'other'
-  slippage: string
-  walletAddress: string | undefined
-  effectiveReceiveAddress: string
-  isSellAssetEvm: boolean
-  isSellAssetUtxo: boolean
-  isSellAssetSolana: boolean
-  isBuyAssetEvm: boolean
-}
-
-export type SwapMachineEvent =
-  | { type: 'SET_SELL_ASSET'; asset: Asset }
-  | { type: 'SET_BUY_ASSET'; asset: Asset }
-  | { type: 'SET_SELL_AMOUNT'; amount: string; amountBaseUnit: string | undefined }
-  | { type: 'SET_SLIPPAGE'; slippage: string }
-  | { type: 'SELECT_RATE'; rate: TradeRate }
-  | { type: 'FETCH_QUOTE' }
-  | { type: 'QUOTE_SUCCESS'; quote: QuoteResponse }
-  | { type: 'QUOTE_ERROR'; error: string }
-  | { type: 'APPROVE' }
-  | { type: 'APPROVAL_SUCCESS'; txHash: string }
-  | { type: 'APPROVAL_ERROR'; error: string }
-  | { type: 'EXECUTE_SUCCESS'; txHash: string }
-  | { type: 'EXECUTE_ERROR'; error: string }
-  | { type: 'STATUS_CONFIRMED' }
-  | { type: 'STATUS_FAILED'; error: string }
-  | { type: 'RETRY' }
-  | { type: 'RESET' }
-  | { type: 'SET_WALLET_ADDRESS'; address: string | undefined }
-  | { type: 'SET_RECEIVE_ADDRESS'; address: string }
-  | {
-      type: 'UPDATE_CHAIN_INFO'
-      chainType: SwapMachineContext['chainType']
-      isSellAssetEvm: boolean
-      isSellAssetUtxo: boolean
-      isSellAssetSolana: boolean
-      isBuyAssetEvm: boolean
-    }

package/src/services/transactionStatus.ts

@@ -1,322 +0,0 @@
-import type { Connection, SignatureStatus } from '@solana/web3.js'
-import type { PublicClient } from 'viem'
-import { createPublicClient, http } from 'viem'
-import { arbitrum, avalanche, base, bsc, gnosis, mainnet, optimism, polygon } from 'viem/chains'
-
-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
-}
-
-type EvmChain =
-  | typeof mainnet
-  | typeof optimism
-  | typeof bsc
-  | typeof gnosis
-  | typeof polygon
-  | typeof base
-  | typeof arbitrum
-  | typeof avalanche
-
-const EVM_CHAINS_BY_ID: Record<number, EvmChain> = {
-  1: mainnet,
-  10: optimism,
-  56: bsc,
-  100: gnosis,
-  137: polygon,
-  8453: base,
-  42161: arbitrum,
-  43114: avalanche,
-}
-
-const MEMPOOL_API_BASE = 'https://mempool.space/api'
-
-export const checkEvmStatus = async (
-  txHash: string,
-  chainId: number,
-  existingClient?: PublicClient,
-): Promise<TransactionStatusResult> => {
-  try {
-    const chain = EVM_CHAINS_BY_ID[chainId]
-    const client =
-      existingClient ??
-      createPublicClient({
-        chain: chain ?? mainnet,
-        transport: http(),
-      })
-
-    const receipt = await client.getTransactionReceipt({
-      hash: txHash as `0x${string}`,
-    })
-
-    if (!receipt) {
-      return { status: 'pending' }
-    }
-
-    const currentBlock = await client.getBlockNumber()
-    const confirmations = Number(currentBlock - receipt.blockNumber) + 1
-
-    if (receipt.status === 'success') {
-      return {
-        status: 'confirmed',
-        confirmations,
-        blockNumber: Number(receipt.blockNumber),
-      }
-    }
-
-    return {
-      status: 'failed',
-      blockNumber: Number(receipt.blockNumber),
-      error: 'Transaction reverted',
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-
-    if (
-      errorMessage.includes('could not be found') ||
-      errorMessage.includes('Transaction not found')
-    ) {
-      return { status: 'pending' }
-    }
-
-    return {
-      status: 'pending',
-      error: errorMessage,
-    }
-  }
-}
-
-export const checkBitcoinStatus = async (
-  txid: string,
-  network: 'mainnet' | 'testnet' = 'mainnet',
-): Promise<TransactionStatusResult> => {
-  try {
-    const baseUrl = network === 'testnet' ? 'https://mempool.space/testnet/api' : MEMPOOL_API_BASE
-
-    const response = await fetch(`${baseUrl}/tx/${txid}/status`)
-
-    if (!response.ok) {
-      if (response.status === 404) {
-        return { status: 'pending' }
-      }
-      throw new Error(`HTTP error: ${response.status}`)
-    }
-
-    const data: BitcoinTransactionStatus = await response.json()
-
-    if (data.confirmed) {
-      const currentBlockResponse = await fetch(`${baseUrl}/blocks/tip/height`)
-      const currentBlockHeight = await currentBlockResponse.json()
-
-      const confirmations = data.block_height
-        ? Number(currentBlockHeight) - data.block_height + 1
-        : 1
-
-      return {
-        status: 'confirmed',
-        confirmations,
-        blockNumber: data.block_height,
-      }
-    }
-
-    return { status: 'pending' }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    return {
-      status: 'pending',
-      error: errorMessage,
-    }
-  }
-}
-
-export const checkSolanaStatus = async (
-  signature: string,
-  connection: Connection,
-): Promise<TransactionStatusResult> => {
-  try {
-    const statusResult = await connection.getSignatureStatus(signature, {
-      searchTransactionHistory: true,
-    })
-
-    const status: SignatureStatus | null = statusResult?.value
-
-    if (!status) {
-      return { status: 'pending' }
-    }
-
-    if (status.err) {
-      return {
-        status: 'failed',
-        error: typeof status.err === 'string' ? status.err : JSON.stringify(status.err),
-      }
-    }
-
-    if (status.confirmationStatus === 'finalized' || status.confirmationStatus === 'confirmed') {
-      return {
-        status: 'confirmed',
-        confirmations: status.confirmations ?? undefined,
-        blockNumber: status.slot,
-      }
-    }
-
-    if (status.confirmationStatus === 'processed') {
-      return {
-        status: 'pending',
-        confirmations: status.confirmations ?? undefined,
-        blockNumber: status.slot,
-      }
-    }
-
-    return { status: 'pending' }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    return {
-      status: 'pending',
-      error: errorMessage,
-    }
-  }
-}
-
-export const waitForEvmConfirmation = async (
-  txHash: string,
-  chainId: number,
-  confirmations = 1,
-  timeoutMs = 120000,
-): Promise<TransactionStatusResult> => {
-  const chain = EVM_CHAINS_BY_ID[chainId]
-  const client = createPublicClient({
-    chain: chain ?? mainnet,
-    transport: http(),
-  })
-
-  const receipt = await client.waitForTransactionReceipt({
-    hash: txHash as `0x${string}`,
-    confirmations,
-    timeout: timeoutMs,
-  })
-
-  if (receipt.status === 'success') {
-    return {
-      status: 'confirmed',
-      confirmations,
-      blockNumber: Number(receipt.blockNumber),
-    }
-  }
-
-  return {
-    status: 'failed',
-    blockNumber: Number(receipt.blockNumber),
-    error: 'Transaction reverted',
-  }
-}
-
-export const waitForBitcoinConfirmation = async (
-  txid: string,
-  requiredConfirmations = 1,
-  pollIntervalMs = 30000,
-  timeoutMs = 600000,
-  network: 'mainnet' | 'testnet' = 'mainnet',
-): Promise<TransactionStatusResult> => {
-  const startTime = Date.now()
-
-  while (Date.now() - startTime < timeoutMs) {
-    const result = await checkBitcoinStatus(txid, network)
-
-    if (result.status === 'confirmed' && (result.confirmations ?? 0) >= requiredConfirmations) {
-      return result
-    }
-
-    if (result.status === 'failed') {
-      return result
-    }
-
-    await new Promise(resolve => setTimeout(resolve, pollIntervalMs))
-  }
-
-  return {
-    status: 'pending',
-    error: 'Timeout waiting for confirmation',
-  }
-}
-
-export const waitForSolanaConfirmation = async (
-  signature: string,
-  connection: Connection,
-  commitment: 'confirmed' | 'finalized' = 'confirmed',
-): Promise<TransactionStatusResult> => {
-  try {
-    const latestBlockhash = await connection.getLatestBlockhash()
-
-    await connection.confirmTransaction(
-      {
-        signature,
-        blockhash: latestBlockhash.blockhash,
-        lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
-      },
-      commitment,
-    )
-
-    return await checkSolanaStatus(signature, connection)
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-
-    if (errorMessage.includes('block height exceeded')) {
-      return {
-        status: 'failed',
-        error: 'Transaction expired',
-      }
-    }
-
-    return {
-      status: 'failed',
-      error: errorMessage,
-    }
-  }
-}
-
-export type ChainType = 'evm' | 'utxo' | 'solana'
-
-export type CheckStatusParams = {
-  txHash: string
-  chainType: ChainType
-  chainId?: number
-  connection?: Connection
-  network?: 'mainnet' | 'testnet'
-}
-
-export const checkTransactionStatus = async (
-  params: CheckStatusParams,
-): Promise<TransactionStatusResult> => {
-  const { txHash, chainType, chainId, connection, network = 'mainnet' } = params
-
-  switch (chainType) {
-    case 'evm':
-      if (!chainId) {
-        throw new Error('chainId is required for EVM transactions')
-      }
-      return await checkEvmStatus(txHash, chainId)
-
-    case 'utxo':
-      return await checkBitcoinStatus(txHash, network)
-
-    case 'solana':
-      if (!connection) {
-        throw new Error('connection is required for Solana transactions')
-      }
-      return await checkSolanaStatus(txHash, connection)
-
-    default:
-      throw new Error(`Unsupported chain type: ${chainType}`)
-  }
-}