@b3dotfun/sdk 0.0.23 → 0.0.24

package/dist/esm/bondkit/bondkitTokenFactory.js

@@ -0,0 +1,270 @@
+import { createPublicClient, createWalletClient, custom, decodeEventLog, getContract, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { BondkitTokenFactoryABI } from "./abis/index.js";
+import { getConfig } from "./config.js";
+// Define the event ABI snippet for BondkitTokenCreated specifically for decoding
+const bondkitTokenCreatedEventAbi = BondkitTokenFactoryABI.find(item => item.type === "event" && item.name === "BondkitTokenCreated");
+export class BondkitTokenFactory {
+    constructor(chainId, walletKey) {
+        if (walletKey && !walletKey.startsWith("0x")) {
+            this.walletKey = `0x${walletKey}`;
+        }
+        else if (walletKey) {
+            this.walletKey = walletKey;
+        }
+        const config = getConfig(chainId);
+        this.chain = config.chain;
+        this.contractAddress = config.factoryAddress;
+        this.rpcUrl = config.rpcUrl;
+        this.publicClient = createPublicClient({
+            chain: this.chain,
+            transport: http(this.rpcUrl),
+        });
+        this.walletClientInstance = createWalletClient({
+            chain: this.chain,
+            transport: http(this.rpcUrl),
+            account: this.walletKey ? privateKeyToAccount(this.walletKey) : undefined,
+        });
+        this.contract = getContract({
+            address: this.contractAddress,
+            abi: BondkitTokenFactoryABI,
+            client: this.walletClientInstance,
+        });
+    }
+    connect(provider) {
+        try {
+            const transport = provider ? custom(provider) : http(this.rpcUrl);
+            this.connectedProvider = provider;
+            this.walletClientInstance = createWalletClient({
+                chain: this.chain,
+                transport,
+                account: this.walletKey ? privateKeyToAccount(this.walletKey) : undefined,
+            });
+            this.contract = getContract({
+                address: this.contractAddress,
+                abi: BondkitTokenFactoryABI,
+                client: this.walletClientInstance,
+            });
+            this.publicClient = createPublicClient({
+                chain: this.chain,
+                transport,
+            });
+            return true;
+        }
+        catch (error) {
+            console.error("Connection failed:", error);
+            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 = 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 = createWalletClient({
+                chain: this.chain,
+                transport,
+                account: selectedAccount,
+            });
+            this.publicClient = createPublicClient({
+                chain: this.chain,
+                transport,
+            });
+            this.contract = getContract({
+                address: this.contractAddress,
+                abi: 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 = custom(this.connectedProvider);
+                this.walletClientInstance = createWalletClient({
+                    chain: this.chain,
+                    transport,
+                    account: selectedAccount,
+                });
+                this.contract = getContract({
+                    address: this.contractAddress,
+                    abi: 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:";
+        console.error(defaultMessage, error);
+        // You could check for common error signatures here if needed
+        // e.g. if (error.data === "0xsomeErrorCode") throw new Error("Specific known error");
+        throw error;
+    }
+    /**
+     * Deploys a new Bondkit token using the factory.
+     * @param config The configuration for the token to be deployed.
+     * @returns The address of the newly created BondkitToken.
+     */
+    async deployBondkitToken(configArg) {
+        if (!this.walletClientInstance.account && !this.walletKey) {
+            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.");
+        }
+        try {
+            const accountToUse = this.walletKey ? privateKeyToAccount(this.walletKey) : this.walletClientInstance.account;
+            if (!accountToUse) {
+                throw new Error("Account for transaction could not be determined.");
+            }
+            const hash = await this.contract.write.deployBondkitToken([configArg], {
+                account: accountToUse,
+                chain: this.chain,
+            });
+            console.log("hash", hash);
+            const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+            for (const log of receipt.logs) {
+                try {
+                    if (log.topics[0] !== "0x75b2d0aabe689b83d7eb7920447b5ae7bef7f28da01d0beb3e197899392eb0d6") {
+                        continue;
+                    }
+                    const decodedEvent = decodeEventLog({
+                        abi: BondkitTokenFactoryABI,
+                        data: log.data,
+                        topics: log.topics,
+                    });
+                    return decodedEvent.args.tokenAddress;
+                }
+                catch (e) { }
+            }
+            throw new Error("BondkitTokenCreated event not found in transaction logs.");
+        }
+        catch (error) {
+            return this.handleError(error, "deployBondkitToken");
+        }
+    }
+    /**
+     * Gets the configuration of a deployed Bondkit token.
+     * @param tokenAddress The address of the Bondkit token.
+     * @returns The configuration object for the token.
+     */
+    async getBondkitTokenConfig(tokenAddress) {
+        try {
+            const result = await this.contract.read.getBondkitTokenConfig([tokenAddress]);
+            return result;
+        }
+        catch (error) {
+            console.error(`Error getting config for token ${tokenAddress}:`, error);
+            return undefined;
+        }
+    }
+    /**
+     * Gets a list of all Bondkit tokens deployed by this factory.
+     * @returns An array of token addresses.
+     */
+    async getDeployedBondkitTokens() {
+        // ABI returns address[] which viem treats as readonly Address[]
+        try {
+            return await this.contract.read.getDeployedBondkitTokens(); // No arguments if function takes none
+        }
+        catch (error) {
+            console.error("Error getting all deployed tokens:", error);
+            return [];
+        }
+    }
+    /**
+     * Gets the owner of the factory contract.
+     * @returns The address of the owner.
+     */
+    async getOwner() {
+        try {
+            return await this.contract.read.owner(); // No arguments if function takes none
+        }
+        catch (error) {
+            console.error("Error getting factory owner:", error);
+            return undefined;
+        }
+    }
+    /**
+     * Gets the implementation address used for new Bondkit token clones.
+     * @returns The address of the BondkitToken implementation contract.
+     */
+    async getBondkitTokenImplementation() {
+        try {
+            return await this.contract.read.bondkitTokenImplementation(); // No arguments if function takes none
+        }
+        catch (error) {
+            console.error("Error getting Bondkit token implementation address:", error);
+            return undefined;
+        }
+    }
+    // --- Write Methods (Ownership, etc.) --- //
+    /**
+     * Transfers ownership of the factory contract to a new owner.
+     * Requires the current owner to call this method.
+     * @param newOwner The address of the new owner.
+     * @returns A promise that resolves with the transaction hash.
+     */
+    async transferOwnership(newOwner) {
+        if (!this.walletClientInstance.account && !this.walletKey) {
+            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 ? privateKeyToAccount(this.walletKey) : this.walletClientInstance.account;
+            if (!accountToUse) {
+                throw new Error("Account for transaction could not be determined.");
+            }
+            const hash = await this.contract.write.transferOwnership([newOwner], {
+                account: accountToUse,
+                chain: this.chain,
+            });
+            return hash;
+        }
+        catch (error) {
+            return this.handleError(error, "transferOwnership");
+        }
+    }
+}

package/dist/esm/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/esm/bondkit/components/TradingView.js

@@ -0,0 +1,294 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { loadScriptFromCDN } from "./utils/cdn-loader.js";
+import { formatNumberSmall } from "./utils/format.js";
+import { Loader2 } from "lucide-react";
+import { useEffect, useRef, useState } from "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 }) => (_jsx("div", { className: `absolute inset-0 flex items-center justify-center bg-white/50 backdrop-blur-sm ${className || ""}`, children: _jsx(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] = useState("60");
+    const [tradingViewTimezone, setTradingViewTimezone] = useState("");
+    const chartContainerRef = useRef(null);
+    const tvWidgetRef = useRef(null);
+    const [chartLoaded, setChartLoaded] = useState(false);
+    const [showLoading, setShowLoading] = useState(true);
+    const [librariesLoaded, setLibrariesLoaded] = useState(false);
+    const isChangingInterval = useRef(false);
+    // Load TradingView libraries from CDN
+    useEffect(() => {
+        const loadLibraries = async () => {
+            try {
+                // Load TradingView charting library
+                await loadScriptFromCDN("/static/charting_library/charting_library.js");
+                setLibrariesLoaded(true);
+            }
+            catch (error) {
+                console.error("Failed to load TradingView libraries:", error);
+            }
+        };
+        loadLibraries();
+    }, []);
+    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 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]);
+    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 (_jsxs("div", { className: `relative h-[600px] w-full ${className || ""}`, children: [_jsx("div", { className: "h-full w-full", ref: chartContainerRef }), showLoading && !isChangingInterval.current && _jsx(GifLoadingOverlay, {})] }));
+};
+export 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/esm/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/esm/bondkit/components/config/cdn.js

@@ -0,0 +1,55 @@
+/**
+ * CDN Configuration
+ * Configure your CDN URLs here
+ */
+export const 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
+ */
+export function getCDNUrl(path) {
+    return `${CDN_CONFIG.baseUrl}${path}`;
+}
+/**
+ * Get TradingView library path for widget configuration
+ */
+export function getTradingViewLibraryPath() {
+    return getCDNUrl(CDN_CONFIG.chartingLibrary.basePath + "/");
+}
+/**
+ * Check if CDN is enabled (useful for development)
+ */
+export 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
+ */
+export function isUsingCustomDomain() {
+    return !!process.env.NEXT_PUBLIC_CDN_URL;
+}
+/**
+ * Get library path - Always use CDN since static files are removed
+ */
+export function getLibraryPath() {
+    return getTradingViewLibraryPath();
+}

package/dist/esm/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";

package/dist/esm/bondkit/components/index.js

@@ -0,0 +1,4 @@
+export { default as TradingView } from "./TradingView.js";
+export * from "./utils/cdn-loader.js";
+export * from "./utils/format.js";
+export * from "./config/cdn.js";