current-bitcoin-price 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Matěj "Matt" Husák
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# 🚀 current-bitcoin-price
+
+A tiny, friendly TypeScript library to get the current Bitcoin price from pluggable providers (CoinGecko, Binance, ...). 🎯
+
+**Quick summary** (2 lines)
+- Use `fetchCurrentPrice()` for a one-line price lookup (defaults to CoinGecko). ⚡
+- The library uses a Result pattern (ok / err) — no throws for expected failures. ✅
+
+🔔 More providers coming soon — this is the strength of the package
+- We ship a few providers today (CoinGecko default, Binance support) and will add more exchanges and data sources in upcoming releases. The pluggable provider design makes it easy to add and swap providers without changing your application logic. 🌐🔌
+
+## ✨ Quick example (public usage)
+
+```ts
+import { fetchCurrentPrice } from './src/price/fetchCurrentPrice.js'
+
+const res = await fetchCurrentPrice({}) // defaults to CoinGecko, USD (you can override both)
+if (res.success) {
+  console.log('BTC (USD):', res.value) // → 12345.67
+} else {
+  console.warn('Could not fetch price:', res.error)
+}
+```
+
+## 📈 Get price + trend from a provider (advanced & small extra step)
+
+```ts
+import { createPriceProvider } from './src/price/createPriceProvider.js'
+import { PriceProviders } from './src/price/PriceProviders.js'
+
+const provider = createPriceProvider(PriceProviders.COINGECKO)
+// first call will populate the provider's last price
+const res = await provider.getCurrentPrice('usd')
+if (res.success) {
+  console.log('BTC (USD):', res.value)
+  console.log('trend:', provider.getTrend()) // 'up' | 'down' | 'stable' 🔺/🔻/➡️
+}
+```
+
+## 🧩 Result pattern
+- Every call returns either `{ success: true, value }` or `{ success: false, error }`.
+- This makes error handling explicit and composable — you check `res.success` and handle both cases. 🛡️
+
+## 🔧 Using a provider directly (advanced)
+
+```ts
+import { createPriceProvider } from './src/price/createPriceProvider.js'
+import { PriceProviders } from './src/price/PriceProviders.js'
+
+const provider = createPriceProvider(PriceProviders.BINANCE)
+const res = await provider.getCurrentPrice('usd')
+if (res.success) console.log('price:', res.value)
+```
+
+## 📊 Trend (up / down / stable)
+- Providers internally compute a simple trend when they fetch a new price by comparing to the previous value.
+- The trend is one of: `"up" | "down" | "stable"`.
+- Want the trend? Use `provider.getTrend()` after a successful call. 👍
+
+---
+
+## ❤️ Feel free to support
+Lately, I've been spending a lot of time building open-source libraries like this one. If you find it useful, consider supporting my work: `bc1qh9nvunhut73hqwf9rsd6l6c0dqqlkv9j3a723n`. More cool libraries are coming soon! 🙏
+

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Exporting abstract PriceProvider class in case of custom implementations.
+ */
+export { PriceProvider } from './price/PriceProvider.js';
+/**
+ * Factory function to create price provider instances.
+ */
+export { createPriceProvider } from './price/createPriceProvider.js';
+/**
+ * Common types used across the library.
+ */
+export { FIAT } from './types.js';
+export { PriceProviders } from './price/PriceProviders.js';
+/**
+ * Function to fetch the current price using the default provider.
+ * FP approach.
+ */
+export { fetchCurrentPrice } from './price/fetchCurrentPrice.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEzD;;GAEG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAErE;;GAEG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D;;;GAGG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+/**
+ * Exporting abstract PriceProvider class in case of custom implementations.
+ */
+export { PriceProvider } from './price/PriceProvider.js';
+/**
+ * Factory function to create price provider instances.
+ */
+export { createPriceProvider } from './price/createPriceProvider.js';
+/**
+ * Common types used across the library.
+ */
+export { FIAT } from './types.js';
+export { PriceProviders } from './price/PriceProviders.js';
+/**
+ * Function to fetch the current price using the default provider.
+ * FP approach.
+ */
+export { fetchCurrentPrice } from './price/fetchCurrentPrice.js';

package/dist/price/BitcoinPriceService.d.ts

@@ -0,0 +1,3 @@
+export declare class BitcoinPriceService {
+}
+//# sourceMappingURL=BitcoinPriceService.d.ts.map

package/dist/price/BitcoinPriceService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BitcoinPriceService.d.ts","sourceRoot":"","sources":["../../src/price/BitcoinPriceService.ts"],"names":[],"mappings":"AAAA,qBAAa,mBAAmB;CAE/B"}

package/dist/price/BitcoinPriceService.js

@@ -0,0 +1,2 @@
+export class BitcoinPriceService {
+}

package/dist/price/CoinGeckoProvider.d.ts

@@ -0,0 +1,12 @@
+import { PriceProvider } from "./PriceProvider.js";
+export declare class CoinGeckoProvider extends PriceProvider {
+    protected baseApiUrl: string;
+    protected price: number;
+    protected prepareRequestHeaders(): Record<string, string>;
+    /**
+     * Fetch the current price for an asset (defaults to bitcoin/usd)
+     */
+    getCurrentPrice(assetId?: string, fiat?: string): Promise<number>;
+}
+export default CoinGeckoProvider;
+//# sourceMappingURL=CoinGeckoProvider.d.ts.map

package/dist/price/CoinGeckoProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoinGeckoProvider.d.ts","sourceRoot":"","sources":["../../src/price/CoinGeckoProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAEjD,qBAAa,iBAAkB,SAAQ,aAAa;IAEhD,SAAS,CAAC,UAAU,SAAsC;IAG1D,SAAS,CAAC,KAAK,EAAE,MAAM,CAAK;IAG5B,SAAS,CAAC,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMzD;;OAEG;IACG,eAAe,CAAC,OAAO,SAAY,EAAE,IAAI,SAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;CAqB5E;AAED,eAAe,iBAAiB,CAAC"}

package/dist/price/CoinGeckoProvider.js

@@ -0,0 +1,35 @@
+import { PriceProvider } from "./PriceProvider.js";
+export class CoinGeckoProvider extends PriceProvider {
+    constructor() {
+        super(...arguments);
+        // Concrete base URL required by the base class
+        this.baseApiUrl = 'https://api.coingecko.com/api/v3';
+        // Keep last known price; initialized to 0 for definite assignment
+        this.price = 0;
+    }
+    // CoinGecko doesn't need special headers for the public endpoints
+    prepareRequestHeaders() {
+        return {
+            'Accept': 'application/json'
+        };
+    }
+    /**
+     * Fetch the current price for an asset (defaults to bitcoin/usd)
+     */
+    async getCurrentPrice(assetId = 'bitcoin', fiat = 'usd') {
+        const endpoint = `simple/price?ids=${encodeURIComponent(assetId)}&vs_currencies=${encodeURIComponent(fiat)}`;
+        const data = await this.queryApi(endpoint);
+        if (!data) {
+            throw new Error('CoinGecko request failed');
+        }
+        const price = data[assetId]?.[fiat];
+        if (typeof price !== 'number') {
+            throw new Error('Unexpected CoinGecko response shape');
+        }
+        // update trend based on previous price then set new price
+        this.setTrend(price);
+        this.price = price;
+        return price;
+    }
+}
+export default CoinGeckoProvider;

package/dist/price/PriceProvider.d.ts

@@ -0,0 +1,80 @@
+import { FIAT, type Result, type Trend } from '../types.js';
+export declare abstract class PriceProvider {
+    /**
+     * Base URL for the price service API.
+     * @protected
+     */
+    protected abstract baseApiUrl: string;
+    /**
+     * API endpoints for the price service.
+     * ROADMAP: consider adding types for endpoints. + support for history rates.
+     * @protected
+     */
+    protected abstract endpoints: Record<string, string>;
+    /**
+     * Current price of the asset.
+     * Used to determine trend.
+     *
+     * ROADMAP: implement a caching mechanism to store the previous price
+     * @protected
+     */
+    protected price: number;
+    /**
+     * Current trend of the asset price.
+     * Compares to previously fetched price.
+     * @protected
+     */
+    protected trend: Trend;
+    /**
+     * API key for accessing the price service.
+     * NULL by default, since default APIs are free.
+     * @protected
+     */
+    private apiKey;
+    /**
+     * Provider supported fiat representation of BTC price.
+     * @protected
+     */
+    protected abstract supportedFiat: Partial<FIAT>[];
+    /**
+     * Constructor for PriceProvider.
+     * @param apiKey
+     */
+    protected constructor(apiKey?: string);
+    /**
+     * Queries the API endpoint with optional parameters.
+     * @param endpoint
+     * @protected
+     */
+    protected queryApi<T>(endpoint: string): Promise<Result<T, string>>;
+    /**
+     * Updates the trend based on the current price.
+     * Has to be called after fetching a new price and before updating the price property.
+     * @param currentPrice
+     * @protected
+     */
+    protected setTrend(currentPrice: number): void;
+    /**
+     * Fetches the current price for Bitcoin.
+     * Implementations are asynchronous and should return a Promise<number>.
+     * @protected
+     */
+    protected abstract getCurrentPrice(): Promise<Result<number, string>>;
+    /**
+     * Constructs the full endpoint URL.
+     * @param endpoint
+     * @protected
+     */
+    protected setupUrl(endpoint: string): string;
+    /**
+     * Prepares the request headers for API calls.
+     * Provider-specific implementation required.
+     * @protected
+     */
+    protected abstract prepareRequestHeaders(): Record<string, string>;
+    /**
+     * Public accessor for the last computed trend ('up'|'down'|'stable').
+     */
+    getTrend(): Trend;
+}
+//# sourceMappingURL=PriceProvider.d.ts.map

package/dist/price/PriceProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PriceProvider.d.ts","sourceRoot":"","sources":["../../src/price/PriceProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AAG5D,8BAAsB,aAAa;IACjC;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAEtC;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAErD;;;;;;OAMG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,CAAK;IAE5B;;;;OAIG;IACH,SAAS,CAAC,KAAK,EAAE,KAAK,CAAY;IAElC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAuB;IAErC;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;IAElD;;;OAGG;IACH,SAAS,aAAa,MAAM,CAAC,EAAE,MAAM;IAIrC;;;;OAIG;cACa,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAsBzE;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAe9C;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,eAAe,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAErE;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAI5C;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAElE;;OAEG;IACI,QAAQ,IAAI,KAAK;CAGzB"}

package/dist/price/PriceProvider.js

@@ -0,0 +1,86 @@
+import { FIAT } from '../types.js';
+import { ok, err } from '../utils.js';
+export class PriceProvider {
+    /**
+     * Constructor for PriceProvider.
+     * @param apiKey
+     */
+    constructor(apiKey) {
+        /**
+         * Current price of the asset.
+         * Used to determine trend.
+         *
+         * ROADMAP: implement a caching mechanism to store the previous price
+         * @protected
+         */
+        this.price = 0;
+        /**
+         * Current trend of the asset price.
+         * Compares to previously fetched price.
+         * @protected
+         */
+        this.trend = 'stable';
+        /**
+         * API key for accessing the price service.
+         * NULL by default, since default APIs are free.
+         * @protected
+         */
+        this.apiKey = null;
+        if (apiKey)
+            this.apiKey = apiKey;
+    }
+    /**
+     * Queries the API endpoint with optional parameters.
+     * @param endpoint
+     * @protected
+     */
+    async queryApi(endpoint) {
+        const headers = this.prepareRequestHeaders() || {};
+        const url = this.setupUrl(endpoint);
+        const result = await fetch(url, {
+            method: 'GET',
+            headers,
+        });
+        if (!result.ok) {
+            return err(`API request failed with status ${result.status}: ${result.statusText}`);
+        }
+        // ROADMAP: implement data validation here for T
+        const parsed = (await result.json());
+        return ok(parsed);
+    }
+    /**
+     * Updates the trend based on the current price.
+     * Has to be called after fetching a new price and before updating the price property.
+     * @param currentPrice
+     * @protected
+     */
+    setTrend(currentPrice) {
+        // if no previous price, cannot determine trend
+        if (this.price === 0) {
+            return;
+        }
+        if (currentPrice > this.price) {
+            this.trend = 'up';
+        }
+        else if (currentPrice < this.price) {
+            this.trend = 'down';
+        }
+        else {
+            this.trend = 'stable';
+        }
+    }
+    /**
+     * Constructs the full endpoint URL.
+     * @param endpoint
+     * @protected
+     */
+    setupUrl(endpoint) {
+        return `${this.baseApiUrl}/${endpoint}`;
+    }
+    /**
+     * Public accessor for the last computed trend ('up'|'down'|'stable').
+     */
+    getTrend() {
+        return this.trend;
+    }
+}

package/dist/price/PriceProviderFactory.d.ts

@@ -0,0 +1,2 @@
+export declare const createPriceProviderFactory: () => void;
+//# sourceMappingURL=PriceProviderFactory.d.ts.map

package/dist/price/PriceProviderFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PriceProviderFactory.d.ts","sourceRoot":"","sources":["../../src/price/PriceProviderFactory.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,0BAA0B,YAEtC,CAAA"}

package/dist/price/PriceProviderFactory.js

@@ -0,0 +1,3 @@
+export const createPriceProviderFactory = () => {
+    // TODO implement factory logic to create and return different price provider instances
+};

package/dist/price/PriceProviders.d.ts

@@ -0,0 +1,5 @@
+export declare enum PriceProviders {
+    COINGECKO = "coingecko",
+    BINANCE = "binance"
+}
+//# sourceMappingURL=PriceProviders.d.ts.map

package/dist/price/PriceProviders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PriceProviders.d.ts","sourceRoot":"","sources":["../../src/price/PriceProviders.ts"],"names":[],"mappings":"AAAA,oBAAY,cAAc;IACxB,SAAS,cAAc;IACvB,OAAO,YAAY;CACpB"}

package/dist/price/PriceProviders.js

@@ -0,0 +1,5 @@
+export var PriceProviders;
+(function (PriceProviders) {
+    PriceProviders["COINGECKO"] = "coingecko";
+    PriceProviders["BINANCE"] = "binance";
+})(PriceProviders || (PriceProviders = {}));

package/dist/price/__tests__/fetchCurrentPrice.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fetchCurrentPrice.test.d.ts.map

package/dist/price/__tests__/fetchCurrentPrice.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchCurrentPrice.test.d.ts","sourceRoot":"","sources":["../../../src/price/__tests__/fetchCurrentPrice.test.ts"],"names":[],"mappings":""}

package/dist/price/__tests__/fetchCurrentPrice.test.js

@@ -0,0 +1,42 @@
+import { vi, describe, it, expect, beforeEach, afterEach, } from 'vitest';
+// Mock the createPriceProvider module before importing the function under test
+vi.mock('../createPriceProvider.js', () => ({
+    createPriceProvider: vi.fn(),
+}));
+import { fetchCurrentPrice } from '../fetchCurrentPrice.js';
+import { PriceProviders } from '../PriceProviders.js';
+import * as cpModule from '../createPriceProvider.js';
+describe(fetchCurrentPrice.name, () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    it('uses CoinGecko by default and returns success result', async () => {
+        const fakeProvider = {
+            getCurrentPrice: vi
+                .fn()
+                .mockResolvedValue({ success: true, value: 4242 }),
+        };
+        const mockedCreate = cpModule.createPriceProvider;
+        mockedCreate.mockReturnValue(fakeProvider);
+        const res = await fetchCurrentPrice({});
+        expect(cpModule.createPriceProvider).toHaveBeenCalledWith(PriceProviders.COINGECKO);
+        expect(res).toEqual({ success: true, value: 4242 });
+        expect(fakeProvider.getCurrentPrice).toHaveBeenCalledWith('usd');
+    });
+    it('passes provided provider to factory and returns error result', async () => {
+        const fakeProvider = {
+            getCurrentPrice: vi
+                .fn()
+                .mockResolvedValue({ success: false, error: 'oops' }),
+        };
+        const mockedCreate = cpModule.createPriceProvider;
+        mockedCreate.mockReturnValue(fakeProvider);
+        const res = await fetchCurrentPrice({ provider: PriceProviders.BINANCE });
+        expect(cpModule.createPriceProvider).toHaveBeenCalledWith(PriceProviders.BINANCE);
+        expect(res).toEqual({ success: false, error: 'oops' });
+        expect(fakeProvider.getCurrentPrice).toHaveBeenCalledWith('usd');
+    });
+});

package/dist/price/binance/BinanceProvider.d.ts

@@ -0,0 +1,23 @@
+import { PriceProvider } from '../PriceProvider.js';
+import { FIAT, type Result } from '../../types.js';
+/**
+ * Implementation of PriceProvider for Binance public API.
+ * Docs: https://api.binance.com
+ */
+export declare class BinanceProvider extends PriceProvider {
+    protected baseApiUrl: string;
+    protected endpoints: {
+        currentPrice: string;
+    };
+    protected supportedFiat: FIAT[];
+    protected price: number;
+    constructor(apiKey?: string);
+    protected prepareRequestHeaders(): Record<string, string>;
+    /**
+     * Map fiat to Binance symbol suffix. For USD we use USDT as Binance often provides BTCUSDT.
+     */
+    protected mapFiatToSymbolSuffix(fiat: FIAT): string;
+    getCurrentPrice(fiat?: FIAT): Promise<Result<number, string>>;
+}
+export default BinanceProvider;
+//# sourceMappingURL=BinanceProvider.d.ts.map

package/dist/price/binance/BinanceProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinanceProvider.d.ts","sourceRoot":"","sources":["../../../src/price/binance/BinanceProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAE,IAAI,EAAE,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,aAAa;IAChD,SAAS,CAAC,UAAU,SAA6B;IAEjD,SAAS,CAAC,SAAS;;MAEjB;IAGF,SAAS,CAAC,aAAa,SAAwB;IAE/C,SAAS,CAAC,KAAK,EAAE,MAAM,CAAK;gBAEhB,MAAM,CAAC,EAAE,MAAM;IAI3B,SAAS,CAAC,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMzD;;OAEG;IACH,SAAS,CAAC,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAO7C,eAAe,CAAC,IAAI,OAAW,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAwBxE;AAED,eAAe,eAAe,CAAC"}

package/dist/price/binance/BinanceProvider.js

@@ -0,0 +1,53 @@
+import { PriceProvider } from '../PriceProvider.js';
+import { ok, err } from '../../utils.js';
+import { FIAT } from '../../types.js';
+/**
+ * Implementation of PriceProvider for Binance public API.
+ * Docs: https://api.binance.com
+ */
+export class BinanceProvider extends PriceProvider {
+    constructor(apiKey) {
+        super(apiKey);
+        this.baseApiUrl = 'https://api.binance.com';
+        this.endpoints = {
+            currentPrice: 'api/v3/ticker/price',
+        };
+        // Support common fiats; map usd to USDT for Binance pairs
+        this.supportedFiat = [FIAT.USD, FIAT.EUR];
+        this.price = 0;
+    }
+    prepareRequestHeaders() {
+        return {
+            Accept: 'application/json',
+        };
+    }
+    /**
+     * Map fiat to Binance symbol suffix. For USD we use USDT as Binance often provides BTCUSDT.
+     */
+    mapFiatToSymbolSuffix(fiat) {
+        const f = fiat.toLowerCase();
+        if (f === FIAT.USD)
+            return 'USDT';
+        if (f === FIAT.EUR)
+            return 'EUR';
+        return f.toUpperCase();
+    }
+    async getCurrentPrice(fiat = FIAT.USD) {
+        const suffix = this.mapFiatToSymbolSuffix(fiat);
+        const symbol = `BTC${suffix}`;
+        const endpoint = `${this.endpoints.currentPrice}?symbol=${encodeURIComponent(symbol)}`;
+        const result = await this.queryApi(endpoint);
+        if (!result.success) {
+            return err(result.error);
+        }
+        const priceStr = result.value?.price;
+        const price = Number(priceStr);
+        if (!price || Number.isNaN(price)) {
+            return err('Invalid API response: price not found');
+        }
+        this.setTrend(price);
+        this.price = price;
+        return ok(price);
+    }
+}
+export default BinanceProvider;

package/dist/price/binance/__tests__/BinanceProvider.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BinanceProvider.integration.test.d.ts.map

package/dist/price/binance/__tests__/BinanceProvider.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinanceProvider.integration.test.d.ts","sourceRoot":"","sources":["../../../../src/price/binance/__tests__/BinanceProvider.integration.test.ts"],"names":[],"mappings":""}

package/dist/price/binance/__tests__/BinanceProvider.integration.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import BinanceProvider from '../BinanceProvider.js';
+import { FIAT } from '../../../types.js';
+const runIntegration = Boolean(process.env.RUN_INTEGRATION);
+describe('BinanceProvider (integration)', () => {
+    it('fetches real BTC price from Binance (skip unless RUN_INTEGRATION=true)', async () => {
+        if (!runIntegration) {
+            console.warn('Skipping integration test - set RUN_INTEGRATION=true to enable');
+            return;
+        }
+        const p = new BinanceProvider();
+        const res = await p.getCurrentPrice(FIAT.USD);
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(typeof res.value).toBe('number');
+            expect(res.value).toBeGreaterThan(0);
+        }
+    });
+});

package/dist/price/binance/__tests__/BinanceProvider.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BinanceProvider.test.d.ts.map

package/dist/price/binance/__tests__/BinanceProvider.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinanceProvider.test.d.ts","sourceRoot":"","sources":["../../../../src/price/binance/__tests__/BinanceProvider.test.ts"],"names":[],"mappings":""}

package/dist/price/binance/__tests__/BinanceProvider.test.js

@@ -0,0 +1,53 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import BinanceProvider from '../BinanceProvider.js';
+import { FIAT } from '../../../types.js';
+function makeJsonResponse(obj) {
+    // Create a minimal object shaped like a Response and cast it to Response for typing in tests
+    const fake = {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: () => Promise.resolve(obj),
+    };
+    return Promise.resolve(fake);
+}
+describe('BinanceProvider (unit)', () => {
+    let originalFetch;
+    beforeEach(() => {
+        originalFetch = globalThis.fetch;
+        vi.restoreAllMocks();
+    });
+    afterEach(() => {
+        if (originalFetch)
+            globalThis.fetch = originalFetch;
+    });
+    it('parses price correctly', async () => {
+        globalThis.fetch = vi.fn(() => makeJsonResponse({ symbol: 'BTCUSDT', price: '60000.12' }));
+        const p = new BinanceProvider();
+        const res = await p.getCurrentPrice(FIAT.USD);
+        expect(res.success).toBe(true);
+        if (res.success)
+            expect(res.value).toBeCloseTo(60000.12);
+    });
+    it('handles non-ok response', async () => {
+        const fakeErrorResponse = Promise.resolve({
+            ok: false,
+            status: 500,
+            statusText: 'err',
+        });
+        globalThis.fetch = vi.fn(() => fakeErrorResponse);
+        const p = new BinanceProvider();
+        const res = await p.getCurrentPrice(FIAT.USD);
+        expect(res.success).toBe(false);
+        if (!res.success)
+            expect(res.error).toMatch(/API request failed/);
+    });
+    it('handles invalid price', async () => {
+        globalThis.fetch = vi.fn(() => makeJsonResponse({ symbol: 'BTCUSDT', price: 'NaN' }));
+        const p = new BinanceProvider();
+        const res = await p.getCurrentPrice(FIAT.USD);
+        expect(res.success).toBe(false);
+        if (!res.success)
+            expect(res.error).toMatch(/Invalid API response/);
+    });
+});

package/dist/price/coinGecko/CoinGeckoProvider.d.ts

@@ -0,0 +1,18 @@
+import { PriceProvider } from '../PriceProvider.js';
+import { FIAT, type Result } from '../../types.js';
+/**
+ * Implementation of PriceProvider for CoinGecko API.
+ * API Documentation: https://www.coingecko.com/en/api/documentation
+ */
+export declare class CoinGeckoProvider extends PriceProvider {
+    protected baseApiUrl: string;
+    protected endpoints: {
+        currentPrice: string;
+    };
+    protected supportedFiat: FIAT[];
+    protected price: number;
+    constructor(apiKey?: string);
+    protected prepareRequestHeaders(): Record<string, string>;
+    getCurrentPrice(fiat?: string): Promise<Result<number, string>>;
+}
+//# sourceMappingURL=CoinGeckoProvider.d.ts.map

package/dist/price/coinGecko/CoinGeckoProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoinGeckoProvider.d.ts","sourceRoot":"","sources":["../../../src/price/coinGecko/CoinGeckoProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAE,IAAI,EAAE,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,aAAa;IAClD,SAAS,CAAC,UAAU,SAAsC;IAE1D,SAAS,CAAC,SAAS;;MAEjB;IAEF,SAAS,CAAC,aAAa,SAAwB;IAE/C,SAAS,CAAC,KAAK,EAAE,MAAM,CAAK;gBAEhB,MAAM,CAAC,EAAE,MAAM;IAK3B,SAAS,CAAC,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMnD,eAAe,CAAC,IAAI,SAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAwBrE"}

package/dist/price/coinGecko/CoinGeckoProvider.js

@@ -0,0 +1,42 @@
+import { PriceProvider } from '../PriceProvider.js';
+import { err, ok } from '../../utils.js';
+import { FIAT } from '../../types.js';
+/**
+ * Implementation of PriceProvider for CoinGecko API.
+ * API Documentation: https://www.coingecko.com/en/api/documentation
+ */
+export class CoinGeckoProvider extends PriceProvider {
+    constructor(apiKey) {
+        super(apiKey);
+        this.baseApiUrl = 'https://api.coingecko.com/api/v3';
+        this.endpoints = {
+            currentPrice: 'simple/price',
+        };
+        this.supportedFiat = [FIAT.USD, FIAT.EUR];
+        this.price = 0;
+    }
+    // CoinGecko doesn't need special headers for the public endpoints
+    prepareRequestHeaders() {
+        return {
+            Accept: 'application/json',
+        };
+    }
+    async getCurrentPrice(fiat = 'usd') {
+        const url = new URLSearchParams({
+            ids: 'bitcoin',
+            vs_currencies: fiat,
+        });
+        const endpoint = `${this.endpoints.currentPrice}?${url.toString()}`;
+        const result = await this.queryApi(endpoint);
+        if (!result.success) {
+            return err(result.error);
+        }
+        const price = result.value['bitcoin']?.[fiat];
+        if (typeof price !== 'number') {
+            return err('Invalid API response: price not found');
+        }
+        this.setTrend(price);
+        this.price = price;
+        return ok(price);
+    }
+}

package/dist/price/coinGecko/__tests__/CoinGeckoProvider.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CoinGeckoProvider.integration.test.d.ts.map

package/dist/price/coinGecko/__tests__/CoinGeckoProvider.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoinGeckoProvider.integration.test.d.ts","sourceRoot":"","sources":["../../../../src/price/coinGecko/__tests__/CoinGeckoProvider.integration.test.ts"],"names":[],"mappings":""}

package/dist/price/coinGecko/__tests__/CoinGeckoProvider.integration.test.js

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { CoinGeckoProvider } from '../CoinGeckoProvider.js';
+const runIntegration = Boolean(process.env.RUN_INTEGRATION);
+describe('CoinGeckoProvider (integration)', () => {
+    it('fetches real BTC price from CoinGecko (skip unless RUN_INTEGRATION=true)', async () => {
+        if (!runIntegration) {
+            console.warn('Skipping integration test - set RUN_INTEGRATION=true to enable');
+            return;
+        }
+        const p = new CoinGeckoProvider();
+        const res = await p.getCurrentPrice('usd');
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(typeof res.value).toBe('number');
+            expect(res.value).toBeGreaterThan(0);
+        }
+    });
+});

package/dist/price/coinGecko/__tests__/CoinGeckoProvider.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CoinGeckoProvider.test.d.ts.map

package/dist/price/coinGecko/__tests__/CoinGeckoProvider.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoinGeckoProvider.test.d.ts","sourceRoot":"","sources":["../../../../src/price/coinGecko/__tests__/CoinGeckoProvider.test.ts"],"names":[],"mappings":""}

package/dist/price/coinGecko/__tests__/CoinGeckoProvider.test.js

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { CoinGeckoProvider } from '../CoinGeckoProvider.js';
+function makeJsonResponse(obj, okFlag = true) {
+    return Promise.resolve({
+        ok: okFlag,
+        json: () => Promise.resolve(obj),
+    });
+}
+describe(CoinGeckoProvider.name, () => {
+    let originalFetch;
+    beforeEach(() => {
+        originalFetch = globalThis.fetch;
+        vi.restoreAllMocks();
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    it('returns ok result with numeric price', async () => {
+        globalThis.fetch = vi.fn(() => makeJsonResponse({ bitcoin: { usd: 12345 } }));
+        const p = new CoinGeckoProvider();
+        const res = await p.getCurrentPrice('usd');
+        expect(res.success).toBe(true);
+        if (res.success) {
+            expect(res.value).toBe(12345);
+        }
+    });
+    it('returns error when response not ok', async () => {
+        globalThis.fetch = vi.fn(() => Promise.resolve({ ok: false, status: 500, statusText: 'err' }));
+        const p = new CoinGeckoProvider();
+        const res = await p.getCurrentPrice('usd');
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error).toContain('API request failed');
+        }
+    });
+    it('returns error when price shape is unexpected', async () => {
+        globalThis.fetch = vi.fn(() => makeJsonResponse({ btc: { usd: 'NaN' } }));
+        const p = new CoinGeckoProvider();
+        const res = await p.getCurrentPrice('usd');
+        expect(res.success).toBe(false);
+        if (!res.success) {
+            expect(res.error).toMatch(/Invalid API response/i);
+        }
+    });
+});

package/dist/price/createPriceProvider.d.ts

@@ -0,0 +1,5 @@
+import { CoinGeckoProvider } from './coinGecko/CoinGeckoProvider.js';
+import { PriceProviders } from './PriceProviders.js';
+import BinanceProvider from './binance/BinanceProvider.js';
+export declare const createPriceProvider: (provider: PriceProviders) => CoinGeckoProvider | BinanceProvider;
+//# sourceMappingURL=createPriceProvider.d.ts.map

package/dist/price/createPriceProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPriceProvider.d.ts","sourceRoot":"","sources":["../../src/price/createPriceProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,eAAe,MAAM,8BAA8B,CAAC;AAE3D,eAAO,MAAM,mBAAmB,GAAI,UAAU,cAAc,wCAS3D,CAAC"}

package/dist/price/createPriceProvider.js

@@ -0,0 +1,13 @@
+import { CoinGeckoProvider } from './coinGecko/CoinGeckoProvider.js';
+import { PriceProviders } from './PriceProviders.js';
+import BinanceProvider from './binance/BinanceProvider.js';
+export const createPriceProvider = (provider) => {
+    switch (provider) {
+        case PriceProviders.COINGECKO:
+            return new CoinGeckoProvider();
+        case PriceProviders.BINANCE:
+            return new BinanceProvider();
+        default:
+            throw new Error(`Unsupported price provider: ${provider}`);
+    }
+};

package/dist/price/createPriceProvider.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createPriceProvider.test.d.ts.map

package/dist/price/createPriceProvider.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPriceProvider.test.d.ts","sourceRoot":"","sources":["../../src/price/createPriceProvider.test.ts"],"names":[],"mappings":""}

package/dist/price/createPriceProvider.test.js

@@ -0,0 +1,25 @@
+import { describe, it, assert } from 'vitest';
+import { createPriceProvider } from './createPriceProvider.js';
+import { CoinGeckoProvider } from './coinGecko/CoinGeckoProvider.js';
+import { PriceProviders } from './PriceProviders.js';
+import BinanceProvider from './binance/BinanceProvider.js';
+describe(createPriceProvider.name, () => {
+    it('should resolve a correct provider (CoinGecko)', () => {
+        const provider = createPriceProvider(PriceProviders.COINGECKO);
+        assert.equal(provider.constructor.name, CoinGeckoProvider.name);
+    });
+    it('should resolve a correct provider (Binance)', () => {
+        const provider = createPriceProvider(PriceProviders.BINANCE);
+        assert.equal(provider.constructor.name, BinanceProvider.name);
+    });
+    it('should throw an error for unsupported provider', () => {
+        try {
+            // @ts-expect-error - intentionally passing invalid provider to exercise error path
+            createPriceProvider('unsupported_provider');
+            assert.fail('Expected error was not thrown');
+        }
+        catch (e) {
+            assert.equal(e.message, 'Unsupported price provider: unsupported_provider');
+        }
+    });
+});

package/dist/price/fetchCurrentPrice.d.ts

@@ -0,0 +1,7 @@
+import { PriceProviders } from './PriceProviders.js';
+type FetchCurrentPriceParams = {
+    provider?: PriceProviders;
+};
+export declare const fetchCurrentPrice: ({ provider, }: FetchCurrentPriceParams) => Promise<import("../types.js").Result<number, string>>;
+export {};
+//# sourceMappingURL=fetchCurrentPrice.d.ts.map

package/dist/price/fetchCurrentPrice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchCurrentPrice.d.ts","sourceRoot":"","sources":["../../src/price/fetchCurrentPrice.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAIrD,KAAK,uBAAuB,GAAG;IAC7B,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,eAErC,uBAAuB,0DAMzB,CAAC"}

package/dist/price/fetchCurrentPrice.js

@@ -0,0 +1,7 @@
+import { PriceProviders } from './PriceProviders.js';
+import { createPriceProvider } from './createPriceProvider.js';
+import { FIAT } from '../types.js';
+export const fetchCurrentPrice = async ({ provider, }) => {
+    const pricingProvider = createPriceProvider(provider || PriceProviders.COINGECKO);
+    return await pricingProvider.getCurrentPrice(FIAT.USD);
+};

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+export type Ok<T> = {
+    success: true;
+    value: T;
+};
+export type Err<T> = {
+    success: false;
+    error: T;
+};
+export type Result<T, E> = Ok<T> | Err<E>;
+export type Trend = 'up' | 'down' | 'stable';
+export declare enum FIAT {
+    USD = "usd",
+    EUR = "eur"
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,EAAE,CAAC,CAAC,IAAI;IAClB,OAAO,EAAE,IAAI,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,MAAM,MAAM,GAAG,CAAC,CAAC,IAAI;IACnB,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AAE1C,MAAM,MAAM,KAAK,GAAG,IAAI,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE7C,oBAAY,IAAI;IACd,GAAG,QAAQ;IACX,GAAG,QAAQ;CACZ"}

package/dist/types.js

@@ -0,0 +1,5 @@
+export var FIAT;
+(function (FIAT) {
+    FIAT["USD"] = "usd";
+    FIAT["EUR"] = "eur";
+})(FIAT || (FIAT = {}));

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+export declare const ok: <T>(value: T) => {
+    success: true;
+    value: T;
+};
+export declare const err: <E>(error: E) => {
+    success: false;
+    error: E;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,OAAO,CAAC;;;CAG5B,CAAC;AAEH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,OAAO,CAAC;;;CAG7B,CAAC"}

package/dist/utils.js

@@ -0,0 +1,8 @@
+export const ok = (value) => ({
+    success: true,
+    value,
+});
+export const err = (error) => ({
+    success: false,
+    error,
+});

package/dist/vitest.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map

package/dist/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../src/vitest.config.ts"],"names":[],"mappings":";AAEA,wBAQG"}

package/dist/vitest.config.js

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node', // or 'happy-dom' for DOM-like env
+        coverage: {
+            reporter: ['text', 'html'],
+        },
+    },
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "current-bitcoin-price",
+  "version": "1.0.0",
+  "description": "NPM lib that, let's wait for it, has method to get you the current BTC price.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    }
+  },
+  "keywords": [
+    "bitcoin"
+  ],
+  "homepage": "https://github.com/OriginalEveres/current-bitcoin-price#readme",
+  "bugs": {
+    "url": "https://github.com/OriginalEveres/current-bitcoin-price/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OriginalEveres/current-bitcoin-price.git"
+  },
+  "license": "MIT",
+  "author": "Matthew Husak",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p .",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:integration": "RUN_INTEGRATION=true vitest --run --include src/price/**/CoinGeckoProvider.integration.test.ts",
+    "lint": "eslint 'src/**/*.{ts,tsx,js,jsx}'",
+    "format": "prettier --write '**/*.{ts,tsx,js,jsx,json,md}'"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.50.1",
+    "@typescript-eslint/parser": "*",
+    "eslint": "*",
+    "eslint-config-prettier": "*",
+    "eslint-plugin-import": "*",
+    "eslint-plugin-vitest": "*",
+    "prettier": "*",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  }
+}