@b3dotfun/sdk 0.0.23-alpha.10 → 0.0.23-alpha.12

package/dist/cjs/anyspend/react/hooks/useSigMint.d.ts

@@ -8,8 +8,8 @@ export declare const useGenerateSigMintData: ({ recipientAddress, contractAddres
         payload: any;
         collection: {
             description?: string | undefined;
-            metadata?: {} | undefined;
             status?: "DRAFT" | "ACTIVE" | "INACTIVE" | undefined;
+            metadata?: {} | undefined;
             createdAt?: string | undefined;
             updatedAt?: string | undefined;
             logoURI?: string | undefined;

package/dist/cjs/bondkit/bondkitToken.d.ts

@@ -16,8 +16,14 @@ export declare class BondkitToken {
     private rpcUrl;
     private apiEndpoint;
     private walletClientInstance;
+    private connectedProvider?;
     constructor(contractAddress: string, walletKey?: string);
     connect(provider?: EIP1193Provider): boolean;
+    /**
+     * Connects using an EIP-1193 provider and requests accounts, selecting the first one.
+     * Enables frontend wallet flows without requiring a private key.
+     */
+    connectWithProvider(provider: EIP1193Provider): Promise<boolean>;
     private handleError;
     name(): Promise<string | undefined>;
     symbol(): Promise<string | undefined>;

package/dist/cjs/bondkit/bondkitToken.js

@@ -44,6 +44,7 @@ class BondkitToken {
     connect(provider) {
         try {
             const transport = provider ? (0, viem_1.custom)(provider) : (0, viem_1.http)(this.rpcUrl);
+            this.connectedProvider = provider;
             this.walletClientInstance = (0, viem_1.createWalletClient)({
                 chain: this.chain,
                 transport,
@@ -65,6 +66,53 @@ class BondkitToken {
             return false;
         }
     }
+    /**
+     * Connects using an EIP-1193 provider and requests accounts, selecting the first one.
+     * Enables frontend wallet flows without requiring a private key.
+     */
+    async connectWithProvider(provider) {
+        try {
+            const transport = (0, viem_1.custom)(provider);
+            this.connectedProvider = provider;
+            // Try to request accounts (prompt user if needed)
+            let addresses = [];
+            try {
+                const result = await provider.request({ method: "eth_requestAccounts" });
+                if (Array.isArray(result))
+                    addresses = result;
+            }
+            catch (requestErr) {
+                try {
+                    const result = await provider.request({ method: "eth_accounts" });
+                    if (Array.isArray(result))
+                        addresses = result;
+                }
+                catch (_) {
+                    // ignore
+                }
+            }
+            const selectedAccount = (addresses?.[0] ?? undefined);
+            this.walletClientInstance = (0, viem_1.createWalletClient)({
+                chain: this.chain,
+                transport,
+                account: selectedAccount,
+            });
+            this.publicClient = (0, viem_1.createPublicClient)({
+                chain: this.chain,
+                transport,
+            });
+            this.contract = (0, viem_1.getContract)({
+                address: this.contractAddress,
+                abi: abis_1.BondkitTokenABI,
+                client: this.walletClientInstance,
+            });
+            return true;
+        }
+        catch (error) {
+            console.error("Connection failed:", error);
+            return false;
+        }
+    }
     async handleError(error, context) {
         const defaultMessage = context ? `Error in ${context}:` : "An error occurred:";
         console.error(defaultMessage, error);
@@ -301,7 +349,30 @@ class BondkitToken {
     // --- Write Methods --- //
     async executeWrite(functionName, args, options) {
         if (!this.walletClientInstance.account && !this.walletKey) {
-            throw new Error("Wallet key not set or client not connected for write operation.");
+            // Try to resolve an account from a connected EIP-1193 provider on-demand
+            if (this.connectedProvider) {
+                try {
+                    const addresses = (await this.connectedProvider.request({ method: "eth_accounts" }));
+                    const selectedAccount = (addresses?.[0] ?? undefined);
+                    if (selectedAccount) {
+                        const transport = (0, viem_1.custom)(this.connectedProvider);
+                        this.walletClientInstance = (0, viem_1.createWalletClient)({
+                            chain: this.chain,
+                            transport,
+                            account: selectedAccount,
+                        });
+                        this.contract = (0, viem_1.getContract)({
+                            address: this.contractAddress,
+                            abi: abis_1.BondkitTokenABI,
+                            client: this.walletClientInstance,
+                        });
+                    }
+                }
+                catch (_) { }
+            }
+            if (!this.walletClientInstance.account && !this.walletKey) {
+                throw new Error("Wallet key not set or client not connected for write operation.");
+            }
         }
         const accountToUse = this.walletKey ? (0, accounts_1.privateKeyToAccount)(this.walletKey) : this.walletClientInstance.account;
         if (!accountToUse)

package/dist/cjs/bondkit/bondkitTokenFactory.d.ts

@@ -9,8 +9,19 @@ export declare class BondkitTokenFactory {
     private walletKey?;
     private rpcUrl;
     private walletClientInstance;
+    private connectedProvider?;
     constructor(chainId: SupportedChainId, walletKey?: string);
     connect(provider?: EIP1193Provider): boolean;
+    /**
+     * Connects using an EIP-1193 provider and requests accounts, selecting the first one.
+     * Enables frontend wallet flows without requiring a private key.
+     */
+    connectWithProvider(provider: EIP1193Provider): Promise<boolean>;
+    /**
+     * Ensure we have an account set for write operations.
+     * If not, try to resolve from a connected provider and reinitialize the client.
+     */
+    private ensureWriteAccount;
     private handleError;
     /**
      * Deploys a new Bondkit token using the factory.

package/dist/cjs/bondkit/bondkitTokenFactory.js

@@ -37,6 +37,7 @@ class BondkitTokenFactory {
     connect(provider) {
         try {
             const transport = provider ? (0, viem_1.custom)(provider) : (0, viem_1.http)(this.rpcUrl);
+            this.connectedProvider = provider;
             this.walletClientInstance = (0, viem_1.createWalletClient)({
                 chain: this.chain,
                 transport,
@@ -58,6 +59,79 @@ class BondkitTokenFactory {
             return false;
         }
     }
+    /**
+     * Connects using an EIP-1193 provider and requests accounts, selecting the first one.
+     * Enables frontend wallet flows without requiring a private key.
+     */
+    async connectWithProvider(provider) {
+        try {
+            const transport = (0, viem_1.custom)(provider);
+            this.connectedProvider = provider;
+            // Request accounts; fall back to eth_accounts if user already connected
+            let addresses = [];
+            try {
+                const result = await provider.request({ method: "eth_requestAccounts" });
+                if (Array.isArray(result))
+                    addresses = result;
+            }
+            catch (requestErr) {
+                try {
+                    const result = await provider.request({ method: "eth_accounts" });
+                    if (Array.isArray(result))
+                        addresses = result;
+                }
+                catch (_) { }
+            }
+            const selectedAccount = (addresses?.[0] ?? undefined);
+            this.walletClientInstance = (0, viem_1.createWalletClient)({
+                chain: this.chain,
+                transport,
+                account: selectedAccount,
+            });
+            this.publicClient = (0, viem_1.createPublicClient)({
+                chain: this.chain,
+                transport,
+            });
+            this.contract = (0, viem_1.getContract)({
+                address: this.contractAddress,
+                abi: abis_1.BondkitTokenFactoryABI,
+                client: this.walletClientInstance,
+            });
+            return true;
+        }
+        catch (error) {
+            console.error("Connection failed:", error);
+            return false;
+        }
+    }
+    /**
+     * Ensure we have an account set for write operations.
+     * If not, try to resolve from a connected provider and reinitialize the client.
+     */
+    async ensureWriteAccount() {
+        if (this.walletClientInstance.account || this.walletKey)
+            return;
+        if (!this.connectedProvider)
+            return;
+        try {
+            const addresses = (await this.connectedProvider.request({ method: "eth_accounts" }));
+            const selectedAccount = (addresses?.[0] ?? undefined);
+            if (selectedAccount) {
+                const transport = (0, viem_1.custom)(this.connectedProvider);
+                this.walletClientInstance = (0, viem_1.createWalletClient)({
+                    chain: this.chain,
+                    transport,
+                    account: selectedAccount,
+                });
+                this.contract = (0, viem_1.getContract)({
+                    address: this.contractAddress,
+                    abi: abis_1.BondkitTokenFactoryABI,
+                    client: this.walletClientInstance,
+                });
+            }
+        }
+        catch (_) { }
+    }
     // TODO: Implement a more generic handleError based on leaderboards-sdk style if common errors are identified
     async handleError(error, context) {
         const defaultMessage = context ? `Error in ${context}:` : "An error occurred:";
@@ -73,7 +147,10 @@ class BondkitTokenFactory {
      */
     async deployBondkitToken(configArg) {
         if (!this.walletClientInstance.account && !this.walletKey) {
-            throw new Error("Wallet key not set or client not connected with an account.");
+            await this.ensureWriteAccount();
+            if (!this.walletClientInstance.account && !this.walletKey) {
+                throw new Error("Wallet key not set or client not connected with an account.");
+            }
         }
         if (!bondkitTokenCreatedEventAbi) {
             throw new Error("BondkitTokenCreated event ABI not found.");
@@ -173,7 +250,10 @@ class BondkitTokenFactory {
      */
     async transferOwnership(newOwner) {
         if (!this.walletClientInstance.account && !this.walletKey) {
-            throw new Error("Wallet key not set or client not connected with an account for write operation.");
+            await this.ensureWriteAccount();
+            if (!this.walletClientInstance.account && !this.walletKey) {
+                throw new Error("Wallet key not set or client not connected with an account for write operation.");
+            }
         }
         try {
             const accountToUse = this.walletKey ? (0, accounts_1.privateKeyToAccount)(this.walletKey) : this.walletClientInstance.account;

package/dist/cjs/bondkit/components/TradingView.d.ts

@@ -0,0 +1,3 @@
+import { TradingViewProps } from "./types";
+declare const TradingView: ({ className, tokenAddress, tokenSymbol }: TradingViewProps) => import("react/jsx-runtime").JSX.Element;
+export default TradingView;

package/dist/cjs/bondkit/components/TradingView.js

@@ -0,0 +1,296 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cdn_loader_1 = require("./utils/cdn-loader");
+const format_1 = require("./utils/format");
+const lucide_react_1 = require("lucide-react");
+const react_1 = require("react");
+// TradingView will be available on window after loading from CDN
+// Datafeed will be implemented inline
+// Mock loading overlay - replace with your actual loading component
+const GifLoadingOverlay = ({ className }) => ((0, jsx_runtime_1.jsx)("div", { className: `absolute inset-0 flex items-center justify-center bg-white/50 backdrop-blur-sm ${className || ""}`, children: (0, jsx_runtime_1.jsx)(lucide_react_1.Loader2, { className: "text-secondary-grey h-8 w-8 animate-spin" }) }));
+const TradingView = ({ className, tokenAddress, tokenSymbol }) => {
+    const theme = "light";
+    // Use token info for the current trade
+    const currentTrade = {
+        product_id: tokenAddress && tokenSymbol ? `${tokenSymbol}-${tokenAddress}` : "BONDKIT",
+    };
+    const [tradingViewDefaultInterval, setTradingViewDefaultInterval] = (0, react_1.useState)("60");
+    const [tradingViewTimezone, setTradingViewTimezone] = (0, react_1.useState)("");
+    const chartContainerRef = (0, react_1.useRef)(null);
+    const tvWidgetRef = (0, react_1.useRef)(null);
+    const [chartLoaded, setChartLoaded] = (0, react_1.useState)(false);
+    const [showLoading, setShowLoading] = (0, react_1.useState)(true);
+    const [librariesLoaded, setLibrariesLoaded] = (0, react_1.useState)(false);
+    const isChangingInterval = (0, react_1.useRef)(false);
+    // Load TradingView libraries from CDN
+    (0, react_1.useEffect)(() => {
+        const loadLibraries = async () => {
+            try {
+                // Load TradingView charting library
+                await (0, cdn_loader_1.loadScriptFromCDN)("/static/charting_library/charting_library.js");
+                setLibrariesLoaded(true);
+            }
+            catch (error) {
+                console.error("Failed to load TradingView libraries:", error);
+            }
+        };
+        loadLibraries();
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (!chartContainerRef.current || !librariesLoaded)
+            return;
+        // Create UDF-compatible datafeed that mimics the original UDFCompatibleDatafeed
+        const createUDFDatafeed = (baseUrl) => {
+            return {
+                onReady: (callback) => {
+                    // Fetch configuration from UDF config endpoint
+                    fetch(`${baseUrl}/config`)
+                        .then(response => response.json())
+                        .then(config => callback(config))
+                        .catch(() => {
+                        // Fallback configuration if config endpoint fails
+                        callback({
+                            supported_resolutions: ["1", "5", "15", "30", "60", "1D", "1W", "1M"],
+                            supports_group_request: false,
+                            supports_marks: false,
+                            supports_search: false,
+                            supports_timescale_marks: false,
+                        });
+                    });
+                },
+                searchSymbols: () => { },
+                resolveSymbol: (symbolName, onSymbolResolvedCallback) => {
+                    // Try to fetch symbol info from UDF endpoint
+                    fetch(`${baseUrl}/symbols?symbol=${symbolName}`)
+                        .then(response => response.json())
+                        .then(symbolInfo => onSymbolResolvedCallback(symbolInfo))
+                        .catch(() => {
+                        // Fallback symbol info
+                        onSymbolResolvedCallback({
+                            name: symbolName,
+                            ticker: symbolName,
+                            description: symbolName,
+                            type: "crypto",
+                            session: "24x7",
+                            timezone: "Etc/UTC",
+                            exchange: "BONDKIT",
+                            minmov: 1,
+                            pricescale: 10000,
+                            has_intraday: true,
+                            supported_resolutions: ["1", "5", "15", "30", "60", "1D", "1W", "1M"],
+                        });
+                    });
+                },
+                getBars: async (symbolInfo, resolution, periodParams, onHistoryCallback) => {
+                    try {
+                        const { from, to, countback } = periodParams;
+                        // Build URL with parameters matching production
+                        const params = new URLSearchParams({
+                            symbol: symbolInfo.ticker,
+                            resolution: resolution,
+                            from: from.toString(),
+                            to: to.toString(),
+                            currencyCode: "ETH",
+                        });
+                        // Add countback if provided
+                        if (countback) {
+                            params.append("countback", countback.toString());
+                        }
+                        const response = await fetch(`${baseUrl}/history?${params}`);
+                        if (!response.ok) {
+                            throw new Error(`HTTP error! status: ${response.status}`);
+                        }
+                        const data = await response.json();
+                        if (data.s === "ok" && data.t && data.t.length > 0) {
+                            const bars = data.t.map((time, index) => ({
+                                time: parseInt(time) * 1000, // Convert string to number, then to milliseconds
+                                open: parseFloat(data.o[index]), // Parse string to number
+                                high: parseFloat(data.h[index]),
+                                low: parseFloat(data.l[index]),
+                                close: parseFloat(data.c[index]),
+                                volume: data.v ? parseFloat(data.v[index]) : 0, // Parse volume string to number
+                            }));
+                            onHistoryCallback(bars, { noData: false });
+                        }
+                        else {
+                            onHistoryCallback([], { noData: true });
+                        }
+                    }
+                    catch (error) {
+                        console.error("Error fetching bars:", error);
+                        onHistoryCallback([], { noData: true });
+                    }
+                },
+                subscribeBars: () => { },
+                unsubscribeBars: () => { },
+            };
+        };
+        const datafeed = createUDFDatafeed("https://b3-udf-worker.sean-430.workers.dev/bondkit/udf");
+        // Calculate timeframe for last 2 days
+        const currentTime = Math.floor(Date.now() / 1000);
+        const twoDaysAgo = currentTime - 2 * 24 * 60 * 60; // 2 days in seconds
+        const widgetOptions = {
+            timeframe: { from: twoDaysAgo, to: currentTime }, // Show last 2 days
+            symbol: currentTrade?.product_id || "BONDKIT",
+            datafeed: datafeed,
+            interval: tradingViewDefaultInterval,
+            container: chartContainerRef.current,
+            library_path: "https://cdn.b3.fun/static/charting_library/",
+            locale: "en",
+            disabled_features: [
+                "use_localstorage_for_settings",
+                "header_symbol_search",
+                "save_chart_properties_to_local_storage",
+                "header_compare",
+                "vert_touch_drag_scroll",
+            ],
+            enabled_features: ["study_templates", "hide_left_toolbar_by_default"],
+            charts_storage_url: "https://saveload.tradingview.com",
+            charts_storage_api_version: "1.1",
+            client_id: "tradingview.com",
+            user_id: "public_user_id",
+            fullscreen: false,
+            autosize: true,
+            timezone: (tradingViewTimezone || getTimezone()),
+            debug: true,
+            // Configure time frame buttons in the bottom left
+            time_frames: [
+                {
+                    text: "5m",
+                    resolution: "5",
+                    description: "5 days in 5 minute intervals",
+                    title: "5m",
+                },
+                {
+                    text: "1h",
+                    resolution: "60",
+                    description: "1 week in 1 hour intervals",
+                    title: "1h",
+                },
+                {
+                    text: "1d",
+                    resolution: "1D",
+                    description: "1 month in 1 day intervals",
+                    title: "1d",
+                },
+                {
+                    text: "1w",
+                    resolution: "1W",
+                    description: "6 months in 1 week intervals",
+                    title: "1w",
+                },
+            ],
+            overrides: {
+                "paneProperties.background": "#FFFFFF",
+                "paneProperties.backgroundType": "solid",
+                "mainSeriesProperties.candleStyle.upColor": "#4AD50D",
+                "mainSeriesProperties.candleStyle.borderUpColor": "#4AD50D",
+                "mainSeriesProperties.candleStyle.downColor": "#F04438",
+                "mainSeriesProperties.candleStyle.borderDownColor": "#F04438",
+                "scalesProperties.fontSize": 10,
+            },
+            studies_overrides: {
+                "volume.volume.color.0": "#80231C",
+                "volume.volume.color.1": "#215611",
+            },
+            loading_screen: {
+                backgroundColor: "transparent",
+            },
+            custom_css_url: "/custom-css/tradingview.css",
+            custom_font_family: "'Roboto', sans-serif",
+            toolbar_bg: "#FFFFFF",
+            theme: "light",
+            custom_formatters: {
+                priceFormatterFactory: () => {
+                    return {
+                        format: (price) => {
+                            if (price < 0.0001) {
+                                return (0, format_1.formatNumberSmall)(price, true);
+                            }
+                            return price.toFixed(4);
+                        },
+                    };
+                },
+            },
+        };
+        const tvWidget = new window.TradingView.widget(widgetOptions);
+        tvWidgetRef.current = tvWidget;
+        tvWidget.onChartReady(() => {
+            setShowLoading(false);
+            setChartLoaded(true);
+            // Subscribe to interval changes
+            tvWidget
+                .activeChart()
+                .onIntervalChanged()
+                .subscribe(null, (interval) => {
+                isChangingInterval.current = true;
+                setTradingViewDefaultInterval(interval);
+                // Reset the flag after a short delay
+                setTimeout(() => {
+                    isChangingInterval.current = false;
+                }, 300);
+            });
+            // Subscribe to timezone changes
+            tvWidget
+                .activeChart()
+                .getTimezoneApi()
+                .onTimezoneChanged()
+                .subscribe(null, (timezone) => {
+                setTradingViewTimezone(timezone);
+            });
+        });
+        return () => {
+            if (tvWidgetRef.current) {
+                tvWidgetRef.current.remove();
+                tvWidgetRef.current = null;
+            }
+        };
+    }, [theme, librariesLoaded]);
+    (0, react_1.useEffect)(() => {
+        if (chartLoaded &&
+            currentTrade?.product_id &&
+            tvWidgetRef.current &&
+            !isChangingInterval.current // Only check symbol if we're not changing interval
+        ) {
+            try {
+                const currentSymbol = tvWidgetRef.current.symbolInterval()?.symbol;
+                const targetSymbol = currentTrade.product_id;
+                // Check if symbols are different (handle both normal and contract address formats)
+                const isSameSymbol = currentSymbol === targetSymbol ||
+                    (currentSymbol && targetSymbol && currentSymbol.split("-")[1] === targetSymbol.split("-")[1]); // Compare contract addresses
+                if (!isSameSymbol) {
+                    setShowLoading(true);
+                    try {
+                        tvWidgetRef.current?.setSymbol?.(targetSymbol, tradingViewDefaultInterval, () => {
+                            setShowLoading(false);
+                        });
+                    }
+                    catch (e) {
+                        console.error("Error setting symbol:", e);
+                        setShowLoading(false);
+                    }
+                }
+            }
+            catch (error) {
+                console.error("Error checking symbol:", error);
+            }
+        }
+    }, [chartLoaded, currentTrade?.product_id, tradingViewDefaultInterval]);
+    return ((0, jsx_runtime_1.jsxs)("div", { className: `relative h-[600px] w-full ${className || ""}`, children: [(0, jsx_runtime_1.jsx)("div", { className: "h-full w-full", ref: chartContainerRef }), showLoading && !isChangingInterval.current && (0, jsx_runtime_1.jsx)(GifLoadingOverlay, {})] }));
+};
+exports.default = TradingView;
+const getTimezone = () => {
+    // Simple timezone detection
+    try {
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        if (timezone === "Asia/Saigon") {
+            return "Asia/Ho_Chi_Minh";
+        }
+        return timezone;
+    }
+    catch (e) {
+        return "UTC";
+    }
+};

package/dist/cjs/bondkit/components/config/cdn.d.ts

@@ -0,0 +1,42 @@
+/**
+ * CDN Configuration
+ * Configure your CDN URLs here
+ */
+export declare const CDN_CONFIG: {
+    readonly baseUrl: string;
+    readonly chartingLibrary: {
+        readonly basePath: "/static/charting_library";
+        readonly files: {
+            readonly main: "/charting_library.js";
+            readonly esm: "/charting_library.esm.js";
+            readonly cjs: "/charting_library.cjs.js";
+            readonly standalone: "/charting_library.standalone.js";
+            readonly types: "/charting_library.d.ts";
+            readonly bundles: "/bundles";
+        };
+    };
+    readonly datafeeds: {
+        readonly basePath: "/static/datafeeds";
+        readonly udf: "/udf/src/udf-compatible-datafeed.js";
+    };
+};
+/**
+ * Get full CDN URL for a resource
+ */
+export declare function getCDNUrl(path: string): string;
+/**
+ * Get TradingView library path for widget configuration
+ */
+export declare function getTradingViewLibraryPath(): string;
+/**
+ * Check if CDN is enabled (useful for development)
+ */
+export declare function isCDNEnabled(): boolean;
+/**
+ * Check if we're using a custom CDN domain vs the default R2 URL
+ */
+export declare function isUsingCustomDomain(): boolean;
+/**
+ * Get library path - Always use CDN since static files are removed
+ */
+export declare function getLibraryPath(): string;

package/dist/cjs/bondkit/components/config/cdn.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * CDN Configuration
+ * Configure your CDN URLs here
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDN_CONFIG = void 0;
+exports.getCDNUrl = getCDNUrl;
+exports.getTradingViewLibraryPath = getTradingViewLibraryPath;
+exports.isCDNEnabled = isCDNEnabled;
+exports.isUsingCustomDomain = isUsingCustomDomain;
+exports.getLibraryPath = getLibraryPath;
+exports.CDN_CONFIG = {
+    // Base CDN URL - will use your custom domain or R2 public URL
+    baseUrl: process.env.NEXT_PUBLIC_CDN_URL || "https://cdn.b3.fun",
+    // TradingView charting library paths
+    chartingLibrary: {
+        basePath: "/static/charting_library",
+        files: {
+            main: "/charting_library.js",
+            esm: "/charting_library.esm.js",
+            cjs: "/charting_library.cjs.js",
+            standalone: "/charting_library.standalone.js",
+            types: "/charting_library.d.ts",
+            bundles: "/bundles",
+        },
+    },
+    // Datafeeds paths
+    datafeeds: {
+        basePath: "/static/datafeeds",
+        udf: "/udf/src/udf-compatible-datafeed.js",
+    },
+};
+/**
+ * Get full CDN URL for a resource
+ */
+function getCDNUrl(path) {
+    return `${exports.CDN_CONFIG.baseUrl}${path}`;
+}
+/**
+ * Get TradingView library path for widget configuration
+ */
+function getTradingViewLibraryPath() {
+    return getCDNUrl(exports.CDN_CONFIG.chartingLibrary.basePath + "/");
+}
+/**
+ * Check if CDN is enabled (useful for development)
+ */
+function isCDNEnabled() {
+    return process.env.NODE_ENV === "production" || process.env.NEXT_PUBLIC_FORCE_CDN === "true";
+}
+/**
+ * Check if we're using a custom CDN domain vs the default R2 URL
+ */
+function isUsingCustomDomain() {
+    return !!process.env.NEXT_PUBLIC_CDN_URL;
+}
+/**
+ * Get library path - Always use CDN since static files are removed
+ */
+function getLibraryPath() {
+    return getTradingViewLibraryPath();
+}

package/dist/cjs/bondkit/components/index.d.ts

@@ -0,0 +1,5 @@
+export { default as TradingView } from "./TradingView";
+export type { TradingViewProps } from "./types";
+export * from "./utils/cdn-loader";
+export * from "./utils/format";
+export * from "./config/cdn";