cryptocurrency blockchain

documentation technical

technology software

finance banking

English

Within the application-focused generic top-level domain (.app), 'grand-jade-ynmmm0tafq-64em3pm1um.edgeone.app' is registered; it also runs on subdomain 'grand-jade-ynmmm0tafq-64em3pm1um'. Count 7 characters in 'edgeone' with four vowels and three consonants. Tokenizing the label suggests two words: edge, one. Average segment length settles at 3.5 characters. No strong language cues emerged from the frequency lists.

html/a3/04/a304bac3-2a07-40c0-b557-3e159e4cf5de.html.gz

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/voice-delight-data

176e894661aa9cdc9a5cba6c720044cbbf7b8bd80d1c9a142a7c24b1b6c50d15

af527c374b56b8688737a42d7fcea7cb8aaeb57a4e3c6da98b4dffd55bcc3514

d4dfa4b7a39a76bd5b69255fac84478363a59ea6f598850af9910dbc756695ae

e43107e542e2e6601af98ff792362c37db999e1692472da9a119e984d5963715

viewport

html/a3/04/a304bac3-2a07-40c0-b557-3e159e4cf5de_nodriver.html.gz

grand-jade-ynmmm0tafq-64em3pm1um.edgeone.app

Prudence Malinki

MarkMonitor Inc.

edgeone.app

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET


  import * as THREE from 'https://cdn.jsdelivr.net/npm/three@0.128.0/build/three.module.js';

  // ---------------------------
  // State
  // ---------------------------
  let BACKEND_HTTP = localStorage.getItem('mp_backend_http') || 'http://localhost:8000';
  let BACKEND_WS   = localStorage.getItem('mp_backend_ws')   || 'ws://localhost:8000/ws';
  let SYMBOL = (localStorage.getItem('mp_symbol') || 'BTCUSDT').toUpperCase();
  let currentTF = '1m';

  const CHART_X_SPACING = 3.5, PRICE_HEIGHT = 14, CANDLE_WIDTH = 0.5;
  const MAX_CANDLES_LOCAL = 1000, SHOW_LAST = 150;

  let finalizedCandles = [];
  let previewCandle = null;
  let hoverInfo = null;
  let needsUpdate = true;
  let streamPaused = false;
  let ws = null, replayWS = null, replayActive = false;

  let indicatorCache = { emaFast: [], emaSlow: [], vwap: [], bb: [] };
  const settings = {
    show: { ema9:true, ema21:true, vwap:true, bb:true, hvn:true, winning:true, sounds:true },
  };

  // ---------------------------
  // Utils
  // ---------------------------
  const clamp = (v,min,max)=>Math.max(min,Math.min(max,v));
  const fmtTime = (ts)=> new Date(ts).toLocaleTimeString([], {hour:'2-digit', minute:'2-digit', second:'2-digit'});
  const kfmt = (n)=> n>=1e9? (n/1e9).toFixed(2)+'B' : n>=1e6? (n/1e6).toFixed(2)+'M' : n>=1e3? (n/1e3).toFixed(2)+'K' : (Math.round(n*100)/100);
  const lerp = (a,b,t)=>a+(b-a)*t;

  function catmullRom(points, segments=8){
    if(points.length<2) return points;
    const res=[];
    for(let i=0;i<points.length-1;i++){
      const p0=points[i-1]||points[i], p1=points[i], p2=points[i+1], p3=points[i+2]||p2;
      for(let j=0;j<segments;j++){
        const t=j/segments, t2=t*t, t3=t2*t;
        const x=0.5*((2*p1.x)+(-p0.x+p2.x)*t+(2*p0.x-5*p1.x+4*p2.x-p3.x)*t2+(-p0.x+3*p1.x-3*p2.x+p3.x)*t3);
        const y=0.5*((2*p1.y)+(-p0.y+p2.y)*t+(2*p0.y-5*p1.y+4*p2.y-p3.y)*t2+(-p0.y+3*p1.y-3*p2.y+p3.y)*t3);
        res.push({x,y});
      }
    }
    res.push(points[points.length-1]);
    return res;
  }

  const Toast = {
    show(msg, color='#e5e7eb') {
      const host = document.getElementById('toast-host');
      const el = document.createElement('div');
      el.className='toast';
      el.innerHTML = `<span style="color:${color};">●</span><div>${msg}</div>`;
      host.appendChild(el);
      setTimeout(()=>{ el.style.opacity='0'; setTimeout(()=>host.removeChild(el),400); }, 3000);
    }
  };

  // ---------------------------
  // Indicators
  // ---------------------------
  function calcEMA(values, len) {
    const k = 2 / (len + 1);
    let prev = null;
    return values.map(v => {
      if (v == null) return null;
      prev = (prev === null) ? v : v * k + prev * (1 - k);
      return prev;
    });
  }

  function recomputeIndicators() {
    const list = [...finalizedCandles, previewCandle].filter(Boolean);
    const closes = list.map(c => c.close);
    indicatorCache.emaFast = calcEMA(closes, parseInt(document.getElementById('inp-ema-fast').value) || 9);
    indicatorCache.emaSlow = calcEMA(closes, parseInt(document.getElementById('inp-ema-slow').value) || 21);
    indicatorCache.vwap    = list.map(c => c.vwap); 
    needsUpdate = true;
  }

  // ---------------------------
  // Graphics Logic
  // ---------------------------
  let scene, camera, renderer, raycaster, mouse;
  let mainGroup, textGroup, pathGroup, axisGroup, overlayGroup;
  let hitMeshes = [], zoom = 1, drag = false, dragBtn = 2, prevMouse = {x:0,y:0};

  function initThree() {
    const container = document.getElementById('canvas-container');
    scene = new THREE.Scene();
    
    const bgGrid = new THREE.GridHelper(400, 200, 0x1e293b, 0x0f172a);
    bgGrid.rotation.x = Math.PI/2; bgGrid.position.z = -3;
    scene.add(bgGrid);

    const w = container.clientWidth, h = container.clientHeight;
    const aspect = w/h, camSize = 10;
    camera = new THREE.OrthographicCamera(-camSize*aspect, camSize*aspect, camSize, -camSize, 1, 1000);
    camera.position.set(0,0,50);

    renderer = new THREE.WebGLRenderer({alpha:true, antialias:true, preserveDrawingBuffer:true});
    renderer.setPixelRatio(Math.min(window.devicePixelRatio||1, 2));
    renderer.setSize(w,h);
    container.appendChild(renderer.domElement);

    mainGroup = new THREE.Group(); scene.add(mainGroup);
    textGroup = new THREE.Group(); scene.add(textGroup);
    pathGroup = new THREE.Group(); scene.add(pathGroup);
    axisGroup = new THREE.Group(); scene.add(axisGroup);
    overlayGroup = new THREE.Group(); scene.add(overlayGroup);

    raycaster = new THREE.Raycaster(); mouse = new THREE.Vector2();

    renderer.domElement.addEventListener('mousedown', e => { 
      if(e.button === 2) { drag = true; prevMouse = {x:e.clientX, y:e.clientY}; e.preventDefault(); }
    });
    window.addEventListener('mouseup', () => drag = false);
    renderer.domElement.addEventListener('contextmenu', e => e.preventDefault());

    renderer.domElement.addEventListener('mousemove', e => {
      const rect = renderer.domElement.getBoundingClientRect();
      mouse.x = ((e.clientX - rect.left) / rect.width) * 2 - 1;
      mouse.y = -((e.clientY - rect.top) / rect.height) * 2 + 1;

      document.getElementById('crosshair-h').style.top = `${e.clientY-rect.top}px`;
      document.getElementById('crosshair-v').style.left = `${e.clientX-rect.left}px`;

      if(drag) {
        camera.position.x -= (e.clientX - prevMouse.x) / zoom * 0.02 * 10;
        camera.position.y += (e.clientY - prevMouse.y) / zoom * 0.02 * 10;
        prevMouse = {x:e.clientX, y:e.clientY};
        needsUpdate = true;
      }
    });

    renderer.domElement.addEventListener('wheel', e => {
      zoom = clamp(zoom - e.deltaY * 0.001, 0.2, 5);
      camera.zoom = zoom; camera.updateProjectionMatrix();
      needsUpdate = true;
    }, {passive:true});

    window.addEventListener('resize', () => {
      const w = container.clientWidth, h = container.clientHeight;
      renderer.setSize(w, h);
      const aspect = w/h, camSize = 10;
      camera.left = -camSize*aspect; camera.right = camSize*aspect;
      camera.updateProjectionMatrix();
      needsUpdate = true;
    });
  }

  function createTextSprite(text, color, size=24) {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    const fontsize = size * 2;
    ctx.font = `Bold ${fontsize}px ui-monospace, SFMono-Regular, Menlo, Monaco`;
    const m = ctx.measureText(text);
    canvas.width = m.width + 10; canvas.height = fontsize + 10;
    ctx.font = `Bold ${fontsize}px ui-monospace, SFMono-Regular, Menlo, Monaco`;
    ctx.fillStyle = color; ctx.textBaseline = 'top';
    ctx.fillText(text, 0, 0);
    const tex = new THREE.CanvasTexture(canvas);
    const mat = new THREE.SpriteMaterial({map:tex, transparent:true});
    const s = new THREE.Sprite(mat);
    s.scale.set((canvas.width/canvas.height)*0.4, 0.4, 1);
    return s;
  }

  function clearGroup(g) {
    while(g.children.length>0) {
      const c = g.children.pop();
      c.geometry?.dispose();
      if(c.material) Array.isArray(c.material) ? c.material.forEach(m=>m.dispose()) : c.material.dispose();
    }
  }

  function updateScene() {
    const list = [...finalizedCandles, previewCandle].filter(Boolean).slice(-SHOW_LAST);
    if(list.length === 0) return;

    clearGroup(mainGroup); clearGroup(textGroup); clearGroup(pathGroup); clearGroup(axisGroup); clearGroup(overlayGroup);
    hitMeshes = [];

    const minP = Math.min(...list.map(c=>c.low)), maxP = Math.max(...list.map(c=>c.high));
    const pRange = (maxP - minP) || 1;
    const scale = (p) => ((p - (minP - pRange*0.1)) / (pRange * 1.2) - 0.5) * PRICE_HEIGHT;

    // Grid Axes
    for(let i=0; i<=8; i++) {
      const p = lerp(minP - pRange*0.1, maxP + pRange*0.1, i/8);
      const y = scale(p);
      const label = createTextSprite(p.toFixed(2), '#94a3b8', 14);
      label.position.set(camera.position.x - 9/zoom, y, 0.1);
      axisGroup.add(label);
    }

    const pathPoints = [];

    list.forEach((candle, idx) => {
      const x = idx * CHART_X_SPACING;
      const openY = scale(candle.open), closeY = scale(candle.close), highY = scale(candle.high), lowY = scale(candle.low);
      
      const wick = new THREE.Line(
        new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(x, highY, -0.1), new THREE.Vector3(x, lowY, -0.1)]),
        new THREE.LineBasicMaterial({color: 0x334155})
      );
      mainGroup.add(wick);

      const body = new THREE.Mesh(
        new THREE.PlaneGeometry(CANDLE_WIDTH, Math.max(0.05, Math.abs(closeY-openY))),
        new THREE.MeshBasicMaterial({color: candle.close >= candle.open ? 0x065f46 : 0x7f1d1d, transparent:true, opacity: 0.3})
      );
      body.position.set(x, (openY+closeY)/2, -0.1);
      mainGroup.add(body);

      // Node Profiles
      const segs = candle.segments || [];
      const maxV = Math.max(...segs.map(s=>s.volume), 0.0001);
      const sorted = [...segs].sort((a,b)=>b.volume - a.volume);

      segs.forEach(s => {
        const sy = scale(s.lastPrice);
        const w = 0.1 + (s.volume/maxV) * 1.5;
        const color = (s.buy > s.sell) ? 0x22c55e : 0xef4444;
        
        const bar = new THREE.Mesh(new THREE.PlaneGeometry(w, 0.1), new THREE.MeshBasicMaterial({color, transparent:true, opacity:0.8}));
        const sideOffset = (s.buy > s.sell) ? -(w/2 + 0.3) : (w/2 + 0.3);
        bar.position.set(x + sideOffset, sy, 0);
        bar.userData = { ...s, time: candle.candleStart, price: s.lastPrice };
        mainGroup.add(bar); hitMeshes.push(bar);

        // Highlights for Rank 1 (POC)
        if(s === sorted[0]) {
          pathPoints.push({x, y: sy});
          const glow = new THREE.Mesh(new THREE.CircleGeometry(0.15, 16), new THREE.MeshBasicMaterial({color: 0xffffff, transparent:true, opacity: 0.6}));
          glow.position.set(x, sy, 0.1);
          mainGroup.add(glow);
        } else if(s === sorted[1]) {
          const glow = new THREE.Mesh(new THREE.CircleGeometry(0.1, 16), new THREE.MeshBasicMaterial({color: 0x94a3b8, transparent:true, opacity: 0.4}));
          glow.position.set(x, sy, 0.09);
          mainGroup.add(glow);
        }
      });
    });

    if(settings.show.winning && pathPoints.length > 1) {
      const smoothed = catmullRom(pathPoints, 6);
      const pts = smoothed.map(p => new THREE.Vector3(p.x, p.y, 0.05));
      pathGroup.add(new THREE.Line(new THREE.BufferGeometry().setFromPoints(pts), new THREE.LineBasicMaterial({color: 0x3b82f6, transparent:true, opacity:0.4})));
    }

    // Indicators
    const drawLine = (arr, color) => {
      const pts = arr.slice(-list.length).map((v, i) => v != null ? new THREE.Vector3(i*CHART_X_SPACING, scale(v), 0.2) : null).filter(Boolean);
      if(pts.length > 1) overlayGroup.add(new THREE.Line(new THREE.BufferGeometry().setFromPoints(pts), new THREE.LineBasicMaterial({color})));
    };
    if(settings.show.ema9) drawLine(indicatorCache.emaFast, 0x10b981);
    if(settings.show.ema21) drawLine(indicatorCache.emaSlow, 0xef4444);
    if(settings.show.vwap) drawLine(indicatorCache.vwap, 0x22d3ee);
  }

  function animate() {
    requestAnimationFrame(animate);
    if(needsUpdate && !streamPaused) {
      updateScene(); needsUpdate = false;
    }

    raycaster.setFromCamera(mouse, camera);
    const intersects = raycaster.intersectObjects(hitMeshes);
    if(intersects.length > 0) {
      hoverInfo = intersects[0].object.userData;
      document.getElementById('hover-placeholder').classList.add('hidden');
      const hc = document.getElementById('hover-content');
      hc.classList.remove('hidden');
      document.getElementById('h-time').innerText = fmtTime(hoverInfo.time);
      document.getElementById('h-price').innerText = hoverInfo.price.toFixed(2);
      document.getElementById('h-vol').innerText = kfmt(hoverInfo.volume);
      document.getElementById('h-speed').innerText = hoverInfo.tickCount;
    } else {
      document.getElementById('hover-placeholder').classList.remove('hidden');
      document.getElementById('hover-content').classList.add('hidden');
    }

    renderer.render(scene, camera);
  }

  // ---------------------------
  // Networking
  // ---------------------------
  async function loadHistory() {
    try {
      setWSStatus('Fetching...');
      const res = await fetch(`${BACKEND_HTTP}/api/candles/${SYMBOL}/${currentTF}?limit=300`);
      if(!res.ok) throw new Error('History fetch failed');
      const data = await res.json();
      finalizedCandles = data.map(c => ({...c, candleStart: c.candleStart || c.time}));
      recomputeIndicators();
      setWSStatus('Live Sync', true);
    } catch(e) {
      setWSStatus('Offline');
      Toast.show('Backend unavailable', '#ef4444');
    }
  }

  function connectLive() {
    if(ws) ws.close();
    ws = new WebSocket(BACKEND_WS);
    ws.onopen = () => ws.send(JSON.stringify({action:'sub', symbol:SYMBOL, tf:currentTF}));
    ws.onmessage = (e) => {
      if(replayActive) return;
      const m = JSON.parse(e.data);
      if(m.type === 'candle_preview') {
        previewCandle = m.candle;
        document.getElementById('live-content').classList.remove('hidden');
        document.getElementById('live-placeholder').classList.add('hidden');
        document.getElementById('l-close').innerText = m.candle.close.toFixed(2);
        document.getElementById('l-buy-vol').innerText = kfmt(m.candle.buyVolTotal);
        document.getElementById('l-sell-vol').innerText = kfmt(m.candle.sellVolTotal);
        document.getElementById('l-buy-tks').innerText = m.candle.buyTicksTotal;
        document.getElementById('l-sell-tks').innerText = m.candle.sellTicksTotal;
        needsUpdate = true;
      } else if(m.type === 'candle_final') {
        finalizedCandles.push(m.candle);
        if(finalizedCandles.length > MAX_CANDLES_LOCAL) finalizedCandles.shift();
        recomputeIndicators();
      }
    };
  }

  // ---------------------------
  // Init
  // ---------------------------
  window.onload = () => {
    initThree();
    animate();

    document.getElementById('inp-backend-http').value = BACKEND_HTTP;
    document.getElementById('inp-backend-ws').value = BACKEND_WS;
    document.getElementById('inp-symbol').value = SYMBOL;

    document.getElementById('btn-save-backend').onclick = () => {
      BACKEND_HTTP = document.getElementById('inp-backend-http').value;
      BACKEND_WS = document.getElementById('inp-backend-ws').value;
      localStorage.setItem('mp_backend_http', BACKEND_HTTP);
      localStorage.setItem('mp_backend_ws', BACKEND_WS);
      loadHistory().then(connectLive);
    };

    document.getElementById('btn-apply-symbol').onclick = () => {
      SYMBOL = document.getElementById('inp-symbol').value.toUpperCase();
      localStorage.setItem('mp_symbol', SYMBOL);
      loadHistory().then(connectLive);
    };

    document.getElementById('sel-timeframe').onchange = (e) => {
      currentTF = e.target.value;
      loadHistory().then(connectLive);
    };

    document.getElementById('btn-play').onclick = (e) => {
      streamPaused = !streamPaused;
      e.target.innerText = streamPaused ? 'Resume' : 'Pause';
    };

    document.getElementById('btn-png').onclick = () => {
      const link = document.createElement('a');
      link.download = `profile-${SYMBOL}-${Date.now()}.png`;
      link.href = renderer.domElement.toDataURL();
      link.click();
    };

    const toggle = (id, key) => document.getElementById(id).onchange = (e) => { settings.show[key] = e.target.checked; needsUpdate=true; };
    toggle('chk-ema9', 'ema9'); toggle('chk-ema21', 'ema21'); toggle('chk-vwap', 'vwap'); 
    toggle('chk-bbands', 'bb'); toggle('chk-hvn', 'hvn'); toggle('chk-winning', 'winning');

    loadHistory().then(connectLive);
  };

  function setWSStatus(txt, ok=false) {
    const el = document.getElementById('ws-status');
    el.innerText = txt;
    el.className = ok ? 'px-2 py-1 rounded text-xs bg-emerald-900/40 text-emerald-400 border border-emerald-800 font-mono' : 'px-2 py-1 rounded text-xs bg-slate-800 text-slate-400 border border-slate-700 font-mono';
  }


Tailwind CSS

✅ Low Risk - https://grand-jade-ynmmm0tafq-64em3pm1um.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
6	43.152.26.58	Singapore	AS15169
6	1	-	-

Security Scan Report: grand-jade-ynmmm0tafq-64em3pm1um.edgeone.app

Summary

AI Security Verdict

Low Risk

Risk Factors

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies1

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History