Building a Bitcoin Real-World Converter: FastAPI, Live APIs, and Financial Precision¶

@app.get("/api/convert", response_model=ConvertResponse)
async def convert(
    btc_amount: Optional[float] = Query(None),
    sats: bool = Query(False),
    item: str = Query(...),
    direction: str = Query("btc_to_item"),
    quantity: Optional[float] = Query(None)
):
    """Convert between BTC and item quantities"""

    # Get BTC price and item price concurrently
    btc_price_task = get_btc_price()
    item_fetcher = get_item_fetcher(item)
    item_price_task = item_fetcher()

    btc_price, item_price = await asyncio.gather(btc_price_task, item_price_task)

    # Perform conversion with decimal precision
    if direction == "btc_to_item":
        btc_decimal = Decimal(str(btc_amount))
        if sats:
            btc_decimal = btc_decimal / Decimal('100000000')

        total_usd = btc_decimal * Decimal(str(btc_price))
        quantity = total_usd / Decimal(str(item_price))

        return ConvertResponse(
            quantity=float(quantity.quantize(Decimal('0.01'))),
            usd_item=float(Decimal(str(item_price)).quantize(Decimal('0.01'))),
            usd_total=float(total_usd.quantize(Decimal('0.01'))),
            btc_price=float(Decimal(str(btc_price)).quantize(Decimal('0.01')))
        )

async def fetch_gold_usd() -> float:
    """Fetch gold price from Alpha Vantage API (per ounce)"""
    api_key = os.getenv('ALPHA_VANTAGE_API_KEY')
    if not api_key:
        return 2000.0  # Fallback price

    try:
        async with httpx.AsyncClient() as client:
            response = await client.get(
                f"https://www.alphavantage.co/query?function=CURRENCY_EXCHANGE_RATE"
                f"&from_currency=USD&to_currency=XAU&apikey={api_key}"
            )
            data = response.json()
            if "Realtime Currency Exchange Rate" in data:
                rate = float(data["Realtime Currency Exchange Rate"]["5. Exchange Rate"])
                return 1.0 / rate  # Convert to USD per ounce
            else:
                raise Exception("No exchange rate data returned")
    except Exception as e:
        print(f"Error fetching gold price from Alpha Vantage: {e}")
        return 2000.0  # Fallback price

function debounceConvert() {
    clearTimeout(debounceTimer);
    debounceTimer = setTimeout(() => {
        if (currentItem && btcInput.value) {
            performConversion();
        }
    }, 300);
}

async function performConversion() {
    const inputElement = currentDirection === 'btc_to_item' 
        ? document.getElementById('btc-input')
        : document.getElementById('quantity-input');

    if (!inputElement || !inputElement.value || !currentItem) {
        return;
    }

    const inputValue = parseFloat(inputElement.value);
    if (inputValue <= 0) {
        showToast('Please enter a positive value', 'error');
        return;
    }

    showLoading(true);

    try {
        const params = new URLSearchParams({
            item: currentItem,
            direction: currentDirection,
            sats: currentUnit === 'sats' ? 'true' : 'false'
        });

        if (currentDirection === 'btc_to_item') {
            params.append('btc_amount', inputValue);
        } else {
            params.append('quantity', inputValue);
        }

        const response = await fetch(`/api/convert?${params}`);

        if (!response.ok) {
            const errorData = await response.json();
            throw new Error(errorData.detail || 'Conversion failed');
        }

        const data = await response.json();
        updateResults(data);

    } catch (error) {
        showToast(error.message, 'error');
        clearResults();
    } finally {
        showLoading(false);
    }
}

function swapDirection() {
    currentDirection = currentDirection === 'btc_to_item' ? 'item_to_btc' : 'btc_to_item';
    updateUIForDirection();
    debounceConvert();
}

function updateUIForDirection() {
    const btcInputGroup = document.querySelector('.btc-input-group');
    const quantityInputGroup = document.querySelector('.quantity-input-group');

    if (currentDirection === 'btc_to_item') {
        btcInputGroup.style.display = 'block';
        quantityInputGroup.style.display = 'none';
        swapBtn.innerHTML = '🔄 Convert Items → BTC';
    } else {
        btcInputGroup.style.display = 'none';
        quantityInputGroup.style.display = 'block';
        swapBtn.innerHTML = '🔄 Convert BTC → Items';
    }
}

function renderChart(data) {
    const dataPoints = data.dates.map((date, index) => ({
        x: new Date(date),
        y: data.btc_prices[index]
    }));

    const chart = new CanvasJS.Chart("chartContainer", {
        animationEnabled: true,
        theme: "light2",
        title: {
            text: `${currentItem.replace('_', ' ').toUpperCase()} Price in BTC`
        },
        axisX: {
            valueFormatString: "MMM YYYY",
            crosshair: {
                enabled: true,
                snapToDataPoint: true
            }
        },
        axisY: {
            title: "BTC",
            includeZero: false,
            prefix: "₿",
            crosshair: {
                enabled: true
            }
        },
        data: [{
            type: "spline",
            name: "Price in BTC",
            showInLegend: true,
            dataPoints: dataPoints
        }]
    });

    chart.render();
}

# Use Decimal for precise financial calculations
btc_decimal = Decimal(str(btc_amount))
if sats:
    btc_decimal = btc_decimal / Decimal('100000000')  # Convert sats to BTC

total_usd_decimal = btc_decimal * Decimal(str(btc_price))
quantity_decimal = total_usd_decimal / Decimal(str(item_price))

# Return properly rounded values
return ConvertResponse(
    quantity=float(quantity_decimal.quantize(Decimal('0.01'))),
    usd_item=float(item_price_decimal.quantize(Decimal('0.01'))),
    usd_total=float(total_usd_decimal.quantize(Decimal('0.01'))),
    btc_price=float(btc_price_decimal.quantize(Decimal('0.01')))
)

# Cache for BTC price (5 min cache)
btc_price_cache = {"price": None, "timestamp": None}

async def get_btc_price() -> float:
    """Fetch current BTC price with caching"""
    current_time = datetime.now()

    # Check if we have a valid cached price
    if (btc_price_cache["price"] is not None and 
        btc_price_cache["timestamp"] is not None and
        (current_time - btc_price_cache["timestamp"]).total_seconds() < 300):  # 5 minutes
        return btc_price_cache["price"]

    # Fetch new price...

# Fetch BTC price and item price concurrently
btc_price_task = get_btc_price()
item_fetcher = get_item_fetcher(item)
item_price_task = item_fetcher()

btc_price, item_price = await asyncio.gather(btc_price_task, item_price_task)

// Prevent excessive API calls with 300ms debounce
function debounceConvert() {
    clearTimeout(debounceTimer);
    debounceTimer = setTimeout(() => {
        if (currentItem && btcInput.value) {
            performConversion();
        }
    }, 300);
}