@shapeshiftoss/swap-widget 0.0.2

package/src/machines/guards.ts

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,288 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,322 @@
+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}`)
+  }
+}