@blockrun/franklin 3.2.4 → 3.3.0

package/dist/trading/data.js

@@ -0,0 +1,112 @@
+const BASE = "https://api.coingecko.com/api/v3";
+const UA = "franklin/3.3.0 (trading)";
+const TIMEOUT = 10_000;
+const TICKER_MAP = {
+    BTC: "bitcoin", ETH: "ethereum", SOL: "solana", BNB: "binancecoin", XRP: "ripple",
+    ADA: "cardano", DOGE: "dogecoin", AVAX: "avalanche-2", DOT: "polkadot", MATIC: "matic-network",
+    LINK: "chainlink", UNI: "uniswap", ATOM: "cosmos", LTC: "litecoin", NEAR: "near",
+    APT: "aptos", ARB: "arbitrum", OP: "optimism", SUI: "sui", SEI: "sei-network",
+    FIL: "filecoin", AAVE: "aave", MKR: "maker", SNX: "synthetix-network-token",
+    COMP: "compound-governance-token", INJ: "injective-protocol", TIA: "celestia",
+    PEPE: "pepe", WIF: "dogwifcoin", RENDER: "render-token",
+};
+const cache = new Map();
+function cached(key, ttlMs, fn) {
+    const hit = cache.get(key);
+    if (hit && hit.expiry > Date.now())
+        return Promise.resolve(hit.data);
+    return fn().then(data => {
+        cache.set(key, { data, expiry: Date.now() + ttlMs });
+        return data;
+    });
+}
+const TTL_PRICE = 5 * 60_000;
+const TTL_OHLCV = 60 * 60_000;
+const TTL_TRENDING = 15 * 60_000;
+// Fetch helper
+async function geckofetch(path) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
+    try {
+        const res = await fetch(`${BASE}${path}`, {
+            headers: { "User-Agent": UA },
+            signal: ctrl.signal,
+        });
+        if (res.status === 429)
+            return "rate-limited: CoinGecko 429 — retry later";
+        if (!res.ok)
+            return `CoinGecko error ${res.status}`;
+        return await res.json();
+    }
+    catch (e) {
+        if (e instanceof DOMException && e.name === "AbortError")
+            return "request timed out";
+        return String(e);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function resolveId(ticker) {
+    return TICKER_MAP[ticker.toUpperCase()] ?? ticker.toLowerCase();
+}
+export async function getPrice(ticker) {
+    const id = resolveId(ticker);
+    return cached(`price:${id}`, TTL_PRICE, async () => {
+        const raw = await geckofetch(`/simple/price?ids=${id}&vs_currencies=usd&include_24hr_change=true&include_market_cap=true&include_24hr_vol=true`);
+        if (typeof raw === "string")
+            return raw;
+        const d = raw[id];
+        if (!d)
+            return `no data for ${ticker}`;
+        return {
+            price: d.usd,
+            change24h: d.usd_24h_change,
+            volume24h: d.usd_24h_vol,
+            marketCap: d.usd_market_cap,
+        };
+    });
+}
+export async function getOHLCV(ticker, days = 30) {
+    const id = resolveId(ticker);
+    return cached(`ohlcv:${id}:${days}`, TTL_OHLCV, async () => {
+        const raw = await geckofetch(`/coins/${id}/market_chart?vs_currency=usd&days=${days}&interval=daily`);
+        if (typeof raw === "string")
+            return raw;
+        const prices = raw.prices;
+        return {
+            timestamps: prices.map(p => p[0]),
+            closes: prices.map(p => p[1]),
+        };
+    });
+}
+export async function getTrending() {
+    return cached("trending", TTL_TRENDING, async () => {
+        const raw = await geckofetch("/search/trending");
+        if (typeof raw === "string")
+            return raw;
+        const coins = raw.coins;
+        return coins.map(c => ({
+            id: c.item.id,
+            name: c.item.name,
+            symbol: c.item.symbol,
+            marketCapRank: c.item.market_cap_rank,
+        }));
+    });
+}
+export async function getMarketOverview() {
+    return cached("markets", TTL_TRENDING, async () => {
+        const raw = await geckofetch("/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=20&page=1");
+        if (typeof raw === "string")
+            return raw;
+        return raw.map(c => ({
+            id: c.id,
+            symbol: c.symbol,
+            name: c.name,
+            price: c.current_price,
+            change24h: c.price_change_percentage_24h,
+            marketCap: c.market_cap,
+            volume24h: c.total_volume,
+        }));
+    });
+}

package/dist/trading/metrics.d.ts

@@ -0,0 +1,29 @@
+export interface RSIResult {
+    value: number;
+    values: number[];
+    interpretation: 'oversold' | 'neutral' | 'overbought';
+}
+export interface MACDResult {
+    macd: number;
+    signal: number;
+    histogram: number;
+    trend: 'bullish' | 'bearish' | 'neutral';
+}
+export interface BollingerResult {
+    upper: number;
+    middle: number;
+    lower: number;
+    bandwidth: number;
+    position: 'above' | 'within' | 'below';
+}
+export interface VolatilityResult {
+    daily: number;
+    annualized: number;
+    interpretation: 'low' | 'medium' | 'high';
+}
+export declare function sma(data: number[], period: number): number;
+export declare function ema(closes: number[], period: number): number[];
+export declare function rsi(closes: number[], period?: number): RSIResult;
+export declare function macd(closes: number[], fast?: number, slow?: number, signal?: number): MACDResult;
+export declare function bollingerBands(closes: number[], period?: number, stdDev?: number): BollingerResult;
+export declare function volatility(closes: number[], period?: number): VolatilityResult;

package/dist/trading/metrics.js

@@ -0,0 +1,105 @@
+export function sma(data, period) {
+    if (data.length < period)
+        return NaN;
+    const slice = data.slice(data.length - period);
+    return slice.reduce((sum, v) => sum + v, 0) / period;
+}
+export function ema(closes, period) {
+    const result = new Array(closes.length).fill(NaN);
+    if (closes.length < period)
+        return result;
+    let sum = 0;
+    for (let i = 0; i < period; i++)
+        sum += closes[i];
+    result[period - 1] = sum / period;
+    const k = 2 / (period + 1);
+    for (let i = period; i < closes.length; i++) {
+        result[i] = closes[i] * k + result[i - 1] * (1 - k);
+    }
+    return result;
+}
+export function rsi(closes, period = 14) {
+    const values = new Array(closes.length).fill(NaN);
+    if (closes.length < period + 1) {
+        return { value: NaN, values, interpretation: 'neutral' };
+    }
+    const gains = [];
+    const losses = [];
+    for (let i = 1; i < closes.length; i++) {
+        const diff = closes[i] - closes[i - 1];
+        gains.push(diff > 0 ? diff : 0);
+        losses.push(diff < 0 ? -diff : 0);
+    }
+    let avgGain = gains.slice(0, period).reduce((s, v) => s + v, 0) / period;
+    let avgLoss = losses.slice(0, period).reduce((s, v) => s + v, 0) / period;
+    const computeRSI = (ag, al) => al === 0 ? 100 : 100 - 100 / (1 + ag / al);
+    values[period] = computeRSI(avgGain, avgLoss);
+    for (let i = period; i < gains.length; i++) {
+        avgGain = (avgGain * (period - 1) + gains[i]) / period;
+        avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
+        values[i + 1] = computeRSI(avgGain, avgLoss);
+    }
+    const latest = values[values.length - 1];
+    const interpretation = latest < 30 ? 'oversold' : latest > 70 ? 'overbought' : 'neutral';
+    return { value: latest, values, interpretation };
+}
+export function macd(closes, fast = 12, slow = 26, signal = 9) {
+    const emaFast = ema(closes, fast);
+    const emaSlow = ema(closes, slow);
+    const macdLine = closes.map((_, i) => isNaN(emaFast[i]) || isNaN(emaSlow[i]) ? NaN : emaFast[i] - emaSlow[i]);
+    const validMacd = macdLine.filter((v) => !isNaN(v));
+    const signalLine = ema(validMacd, signal);
+    const padded = new Array(macdLine.length - validMacd.length)
+        .fill(NaN)
+        .concat(signalLine);
+    const histogram = macdLine.map((v, i) => isNaN(v) || isNaN(padded[i]) ? NaN : v - padded[i]);
+    const last = macdLine[macdLine.length - 1];
+    const lastSignal = padded[padded.length - 1];
+    const lastHist = histogram[histogram.length - 1];
+    const prevHist = histogram[histogram.length - 2];
+    let trend = 'neutral';
+    if (!isNaN(lastHist) && !isNaN(prevHist)) {
+        if (lastHist > 0 && lastHist > prevHist)
+            trend = 'bullish';
+        else if (lastHist < 0 && lastHist < prevHist)
+            trend = 'bearish';
+    }
+    return { macd: last, signal: lastSignal, histogram: lastHist, trend };
+}
+export function bollingerBands(closes, period = 20, stdDev = 2) {
+    if (closes.length < period) {
+        return {
+            upper: NaN,
+            middle: NaN,
+            lower: NaN,
+            bandwidth: NaN,
+            position: 'within',
+        };
+    }
+    const slice = closes.slice(closes.length - period);
+    const middle = slice.reduce((s, v) => s + v, 0) / period;
+    const variance = slice.reduce((s, v) => s + (v - middle) ** 2, 0) / period;
+    const sigma = Math.sqrt(variance);
+    const upper = middle + stdDev * sigma;
+    const lower = middle - stdDev * sigma;
+    const bandwidth = (upper - lower) / middle;
+    const price = closes[closes.length - 1];
+    const position = price > upper ? 'above' : price < lower ? 'below' : 'within';
+    return { upper, middle, lower, bandwidth, position };
+}
+export function volatility(closes, period = 14) {
+    if (closes.length < period + 1) {
+        return { daily: NaN, annualized: NaN, interpretation: 'medium' };
+    }
+    const returns = [];
+    const start = closes.length - period - 1;
+    for (let i = start + 1; i < closes.length; i++) {
+        returns.push(Math.log(closes[i] / closes[i - 1]));
+    }
+    const mean = returns.reduce((s, v) => s + v, 0) / returns.length;
+    const variance = returns.reduce((s, v) => s + (v - mean) ** 2, 0) / (returns.length - 1);
+    const daily = Math.sqrt(variance);
+    const annualized = daily * Math.sqrt(365);
+    const interpretation = annualized < 0.3 ? 'low' : annualized > 0.8 ? 'high' : 'medium';
+    return { daily, annualized, interpretation };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.2.4",
+  "version": "3.3.0",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {