Error Handling

Comprehensive Error Management Guide

Learn how to handle errors gracefully in your Bitcoin applications with LaserEyes' robust error handling system.

Error Types

Categorized errors

Recovery

Error recovery patterns

Debugging

Debug strategies

Error Categories

Network Errors

Handle connection issues, timeouts, and network-related failures gracefully.

Timeout

Connection Lost

Rate Limit

Wallet Errors

Manage wallet connection, signing, and permission-related errors.

Not Connected

Rejected

Insufficient Funds

Transaction Errors

Handle transaction validation, broadcasting, and confirmation errors.

Invalid Input

Broadcast Failed

Unconfirmed

API Errors

Handle API response errors, rate limiting, and data validation issues.

Invalid Response

Rate Limited

Validation

Implementation Examples

Basic Error Handling

import { useLaserEyes, WalletError, NetworkError } from '@omnisat/lasereyes-react'

function WalletConnect() {
  const { connect } = useLaserEyes()

  const handleConnect = async () => {
    try {
      await connect()
    } catch (error) {
      if (error instanceof WalletError) {
        // Handle wallet-specific errors
        console.error('Wallet error:', error.message)
      } else if (error instanceof NetworkError) {
        // Handle network-related errors
        console.error('Network error:', error.message)
      } else {
        // Handle unknown errors
        console.error('Unknown error:', error)
      }
    }
  }
}

Advanced Error Recovery

import { useLaserEyes, useErrorHandler } from '@omnisat/lasereyes-react'

function TransactionComponent() {
  const { sendBitcoin } = useLaserEyes()
  const errorHandler = useErrorHandler({
    onWalletError: async (error) => {
      // Attempt to reconnect wallet
      await reconnectWallet()
    },
    onNetworkError: async (error) => {
      // Retry with exponential backoff
      await retryWithBackoff(async () => {
        // Original transaction logic
      })
    },
    onTransactionError: async (error) => {
      if (error.code === 'INSUFFICIENT_FUNDS') {
        // Show insufficient funds UI
      } else if (error.code === 'BROADCAST_FAILED') {
        // Attempt to rebroadcast
        await rebroadcastTransaction(error.txHex)
      }
    }
  })

  const handleSend = async () => {
    try {
      await sendBitcoin({
        address: 'bc1q...',
        amount: 0.001
      })
    } catch (error) {
      await errorHandler.handle(error)
    }
  }
}

Custom Error Boundaries

import { LaserEyesErrorBoundary } from '@omnisat/lasereyes-react'

function App() {
  return (
    <LaserEyesErrorBoundary
      fallback={({ error, reset }) => (
        <div className="error-container">
          <h2>Something went wrong!</h2>
          <pre>{error.message}</pre>
          <button onClick={reset}>Try again</button>
        </div>
      )}
      onError={(error) => {
        // Log error to monitoring service
        logError(error)
      }}
    >
      <YourApp />
    </LaserEyesErrorBoundary>
  )
}

Best Practices

Error Classification

Always categorize errors properly to provide appropriate user feedback and recovery strategies.

Graceful Degradation

Implement fallback mechanisms and graceful degradation for critical functionality.

Error Boundaries

Use error boundaries to prevent entire app crashes and provide meaningful recovery options.

Error Logging

Implement comprehensive error logging for debugging and monitoring in production.

Custom DataSource

Security