import { getUTXOs, InsufficientUTXOBalanceError } from '@bigmi/core'

try {
  const utxos = await getUTXOs(client, { address: 'bc1...', minValue: 34954 })
  const utxoBalance = utxos.reduce((total, utxo) => total + utxo.value, 0)
  console.log(`UTXO balance: ${utxoBalance} sats`)
} catch (error) {
  if (error instanceof InsufficientUTXOBalanceError) {
    console.error('Insufficient balance for transaction')
  } else {
    console.error('Unknown error:', error.message)
  }
}

import { useConnect } from '@bigmi/react'
import { 
  ConnectorNotFoundError, 
  UserRejectedRequestError 
} from '@bigmi/client'

function ConnectWallet() {
  const { connect } = useConnect()

  const handleConnect = async () => {
    try {
      await connect({ connector: xverse() })
    } catch (error) {
      if (error instanceof ConnectorNotFoundError) {
        alert('Please install Xverse wallet extension')
      } else if (error instanceof UserRejectedRequestError) {
        alert('Connection rejected. Please try again.')
      } else {
        console.error('Connection failed:', error)
      }
    }
  }

  return <button onClick={handleConnect}>Connect Wallet</button>
}

import { 
  sendUTXOTransaction, 
  waitForTransaction,
  withRetry,
  TimeoutError,
  TransactionNotFoundError, 
  getBalance
} from '@bigmi/core'

// Using Bigmi's built-in withRetry utility

// Simple retry with fixed delay
async function getBalanceWithRetry(client, address) {
  return withRetry(
    () => getBalance(client, { address }),
    {
      delay: 2000,     // 2 seconds between retries
      retryCount: 3,   // Try 3 times total
    }
  )
}

async function sendTransactionWithRetry(client, txHex) {
  // Retry transaction broadcasting with exponential backoff
  const txId = await withRetry(
    () => sendUTXOTransaction(client, { hex: txHex }),
    {
      delay: ({ count }) => Math.pow(2, count) * 1000, // 1s, 2s, 4s...
      retryCount: 3,
      shouldRetry: ({ error }) => 
        error instanceof TimeoutError || 
        error instanceof TransactionNotFoundError
    }
  )
  
  // Wait for confirmation with retry logic
  const receipt = await withRetry(
    () => waitForTransaction(client, {
      txId,
      txHex,
      timeout: 30_000 // 30 seconds per attempt
    }),
    {
      delay: 5000, // 5 second delay between retries
      retryCount: 5,
      shouldRetry: ({ error }) => error instanceof TimeoutError
    }
  )
  
  return receipt
}

import { 
  createClient, 
  fallback, 
  mempool, 
  blockchair,
  AllTransportsFailedError 
} from '@bigmi/core'

// Create client with multiple providers for reliability
const client = createClient({
  chain: bitcoin,
  transport: fallback([
    mempool(),
    blockchair(),
    // Add more providers as fallbacks
  ])
})

try {
  const balance = await getBalance(client, { address })
} catch (error) {
  if (error instanceof AllTransportsFailedError) {
    console.error('All Bitcoin providers are down. Please try again later.')
    // Show user-friendly error message
  }
}