Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
export const config = { runtime: 'edge' };
import { getCorsHeaders, isDisallowedOrigin } from './_cors.js';
import { createIpRateLimiter } from './_ip-rate-limit.js';
const limiter = createIpRateLimiter({ limit: 20, windowMs: 60_000 });
const CACHE_TTL = 300; // 5 min
let cachedResponse = null;
let cacheTimestamp = 0;
// Chain locations (inline - Edge Functions can't import from src/)
const CHAIN_LOCATIONS = {
ethereum: { name: 'Ethereum', lat: 47.3769, lon: 8.5417 },
solana: { name: 'Solana', lat: 37.7749, lon: -122.4194 },
bsc: { name: 'BNB Chain', lat: 1.3521, lon: 103.8198 },
tron: { name: 'Tron', lat: 37.5665, lon: 126.978 },
avalanche: { name: 'Avalanche', lat: 40.7128, lon: -74.006 },
fantom: { name: 'Fantom', lat: -33.8688, lon: 151.2093 },
cardano: { name: 'Cardano', lat: 47.0707, lon: 15.4395 },
polkadot: { name: 'Polkadot', lat: 47.42, lon: 8.58 },
cosmos: { name: 'Cosmos', lat: 52.52, lon: 13.405 },
near: { name: 'NEAR', lat: 37.82, lon: -122.47 },
algorand: { name: 'Algorand', lat: 42.3601, lon: -71.0589 },
ton: { name: 'TON', lat: 25.2048, lon: 55.2708 },
arbitrum: { name: 'Arbitrum', lat: 40.76, lon: -73.96 },
optimism: { name: 'Optimism', lat: 37.73, lon: -122.38 },
base: { name: 'Base', lat: 37.82, lon: -122.36 },
polygon: { name: 'Polygon', lat: 19.076, lon: 72.8777 },
zksync: { name: 'zkSync Era', lat: 52.52, lon: 13.45 },
starknet: { name: 'Starknet', lat: 32.0853, lon: 34.7818 },
linea: { name: 'Linea', lat: 48.8566, lon: 2.3522 },
scroll: { name: 'Scroll', lat: 31.2304, lon: 121.4737 },
mantle: { name: 'Mantle', lat: 22.3193, lon: 114.1694 },
blast: { name: 'Blast', lat: 37.39, lon: -122.08 },
manta: { name: 'Manta Pacific', lat: 1.40, lon: 103.87 },
mode: { name: 'Mode', lat: 37.44, lon: -122.16 },
sui: { name: 'Sui', lat: 37.4419, lon: -122.143 },
aptos: { name: 'Aptos', lat: 37.49, lon: -122.18 },
sei: { name: 'Sei', lat: 37.80, lon: -122.41 },
celo: { name: 'Celo', lat: 37.79, lon: -122.44 },
gnosis: { name: 'Gnosis', lat: 52.47, lon: 13.36 },
moonbeam: { name: 'Moonbeam', lat: 42.36, lon: -71.10 },
cronos: { name: 'Cronos', lat: 1.30, lon: 103.78 },
klaytn: { name: 'Klaytn', lat: 37.52, lon: 127.02 },
harmony: { name: 'Harmony', lat: 37.38, lon: -122.08 },
};
const NAME_ALIASES = {
'binance': 'bsc',
'binance smart chain': 'bsc',
'bnb chain': 'bsc',
'polygon pos': 'polygon',
'polygon zkevm': 'polygon',
'zksync era': 'zksync',
'op mainnet': 'optimism',
'avalanche c-chain': 'avalanche',
'avax': 'avalanche',
'ftm': 'fantom',
'manta pacific': 'manta',
};
function normalizeChain(name) {
const lower = (name || '').toLowerCase().trim();
return NAME_ALIASES[lower] ?? lower;
}
function lookupChain(name) {
const key = normalizeChain(name);
return CHAIN_LOCATIONS[key] || null;
}
function buildFallbackResult() {
return {
timestamp: new Date().toISOString(),
flows: [],
bridges: [],
summary: { totalVolume24h: 0, activeBridges: 0, topFlow: null, flowCount: 0 },
unavailable: true,
};
}
export default async function handler(req) {
const cors = getCorsHeaders(req);
if (req.method === 'OPTIONS') {
if (isDisallowedOrigin(req)) return new Response(null, { status: 403, headers: cors });
return new Response(null, { status: 204, headers: cors });
}
if (isDisallowedOrigin(req)) {
return new Response(JSON.stringify({ error: 'Forbidden' }), {
status: 403, headers: { ...cors, 'Content-Type': 'application/json' },
});
}
if (req.method !== 'GET') {
return new Response(JSON.stringify({ error: 'Method not allowed' }), {
status: 405, headers: { ...cors, 'Content-Type': 'application/json', Allow: 'GET, OPTIONS' },
});
}
const clientIp = (req.headers.get('x-forwarded-for') || 'unknown').split(',')[0].trim();
if (!limiter.check(clientIp)) {
return new Response(JSON.stringify({ error: 'Too many requests' }), {
status: 429, headers: { ...cors, 'Content-Type': 'application/json', 'Retry-After': '60' },
});
}
// Serve from in-memory cache
const now = Date.now();
if (cachedResponse && now - cacheTimestamp < CACHE_TTL * 1000) {
return new Response(JSON.stringify(cachedResponse), {
headers: {
...cors,
'Content-Type': 'application/json',
'X-Cache': 'HIT',
'Cache-Control': `public, s-maxage=${CACHE_TTL}, stale-while-revalidate=600`,
},
});
}
try {
const controller = new AbortController();
const id = setTimeout(() => controller.abort(), 12_000);
// Fetch bridges list with chain breakdown
const res = await fetch('https://bridges.llama.fi/bridges?includeChains=true', {
signal: controller.signal,
headers: { Accept: 'application/json' },
});
clearTimeout(id);
if (!res.ok) throw new Error(`DeFiLlama bridges HTTP ${res.status}`);
const data = await res.json();
const bridgesList = data?.bridges || data || [];
// Build flow arcs from bridge data
const flowMap = new Map(); // "src-dst" → aggregated flow
const bridgeSummaries = [];
for (const bridge of bridgesList) {
const name = bridge.displayName || bridge.name || 'Unknown Bridge';
const vol24h = bridge.currentDayVolume ?? bridge.lastDayVolume ?? 0;
const chains = bridge.chains || bridge.destinationChain
? [bridge.sourceChain, bridge.destinationChain].filter(Boolean)
: [];
// Skip bridges with negligible volume
if (vol24h < 10_000) continue;
bridgeSummaries.push({
name,
volume24h: vol24h,
chains: chains.map(c => normalizeChain(c)),
});
// Generate pairwise flows between chains this bridge connects
const resolvedChains = chains
.map(c => ({ orig: c, key: normalizeChain(c), loc: lookupChain(c) }))
.filter(c => c.loc);
for (let i = 0; i < resolvedChains.length; i++) {
for (let j = i + 1; j < resolvedChains.length; j++) {
const src = resolvedChains[i];
const dst = resolvedChains[j];
// Sort alphabetically for consistent dedup key
const [a, b] = src.key < dst.key ? [src, dst] : [dst, src];
const flowKey = `${a.key}-${b.key}`;
if (!flowMap.has(flowKey)) {
flowMap.set(flowKey, {
id: flowKey,
sourceChain: a.key,
targetChain: b.key,
sourceLat: a.loc.lat,
sourceLon: a.loc.lon,
targetLat: b.loc.lat,
targetLon: b.loc.lon,
volume24h: 0,
bridgeName: name,
txCount: 0,
});
}
const flow = flowMap.get(flowKey);
flow.volume24h += vol24h / Math.max(1, resolvedChains.length - 1);
flow.txCount += bridge.currentDayTxs ?? bridge.lastDayTxs ?? 0;
// Keep the bridge name of the highest volume contributor
if (vol24h > flow.volume24h * 0.5) {
flow.bridgeName = name;
}
}
}
}
// Sort flows by volume, keep top 60
const flows = Array.from(flowMap.values())
.sort((a, b) => b.volume24h - a.volume24h)
.slice(0, 60);
const totalVolume24h = flows.reduce((s, f) => s + f.volume24h, 0);
const topFlow = flows[0] ? { from: flows[0].sourceChain, to: flows[0].targetChain } : null;
const result = {
timestamp: new Date().toISOString(),
flows,
bridges: bridgeSummaries.sort((a, b) => b.volume24h - a.volume24h).slice(0, 30),
summary: {
totalVolume24h,
activeBridges: bridgeSummaries.length,
topFlow,
flowCount: flows.length,
},
};
cachedResponse = result;
cacheTimestamp = now;
return new Response(JSON.stringify(result), {
headers: {
...cors,
'Content-Type': 'application/json',
'X-Cache': 'MISS',
'Cache-Control': `public, s-maxage=${CACHE_TTL}, stale-while-revalidate=600`,
},
});
} catch (err) {
console.error('[bridge-flows] Handler error:', err?.message ?? err);
const fallback = cachedResponse || buildFallbackResult();
return new Response(JSON.stringify(fallback), {
status: 200,
headers: { ...cors, 'Content-Type': 'application/json', 'Cache-Control': 'public, s-maxage=60' },
});
}
}