QuantForge

Github Repos

DeltaPulse Wave [ChartPrime] – Standardized Volume Delta Oscillator

DeltaPulse Wave [ChartPrime] – Standardized Volume Delta Oscillator

Key takeaways

  1. Spot trend exhaustion and reversal setups by detecting when price action and volume conviction start disagreeing
  2. Compare orderflow strength across any asset or timeframe without recalibrating, since the oscillator is always normalized to the same -50 to +50 scale
  3. Includes on-chart divergence triangles and sync lines so you can identify signals directly on the price chart without switching panes
  4. Run it locally with PineTS for backtesting or real-time signal generation through the Binance data provider

Loading chartโ€ฆ

Indicator Credits : Author : ChartPrime

Alright, you know how most volume delta indicators have this annoying habit of drifting off into infinity? Cumulative values that keep climbing (or diving) until the chart is basically unreadable? Yeah. ChartPrime’s DeltaPulse Wave fixes that. It normalizes the net difference between buying and selling volume into a bounded oscillator that stays between -50 and +50, no matter what. So a reading of +30 on BTCUSDC means the same thing as +30 on ETHUSDC or SPY. If you’re building multi-asset bots, that’s a game changer right there.

But honestly, the normalization isn’t even the best part. The indicator ships with a full divergence engine that automatically detects when price and volume conviction start disagreeing, and it draws sync lines on both the price chart and the oscillator pane. I’ve been running this on weekly BTCUSDC through PineTS, and the divergence signals are surprisingly clean. Let me walk you through the code and show you how to get it running locally.

Running DeltaPulse Wave with PineTS

PineTS takes your .pine file and runs it in Node.js. Not a simulation, not an approximation. You get the actual calculated values, bar by bar, same as what TradingView would produce, which means your bot can read the oscillator output directly instead of scraping a chart.

Installing PineTS

One command, you’re done:

npm install pinets

Loading the Pine Script Indicator

PineTS reads the raw .pine file, compiles it, and runs it against market data from whatever provider you’re pointed at. Pick your symbol and timeframe and it handles the rest. Back comes an execution context with every plot value, bar by bar, which for DeltaPulse Wave means 13 plots total, overlay divergence shapes included.

Batch Execution with pineTS.run()

This is the simplest path: load the history, run everything at once, get your context back. Good enough for backtesting or a quick sanity check on current state:

// PineTS batch execution example template
import { PineTS, Provider } from 'pinets'
import { readFileSync } from 'node:fs'
import { dirname, join } from 'node:path'
import { fileURLToPath } from 'node:url'

const __dirname = dirname(fileURLToPath(import.meta.url))
const pineScript = readFileSync(join(__dirname, 'source.pine'), 'utf-8')

const pineTS = new PineTS(Provider.Binance, 'BTCUSDC', '1w', 500)
const ctx = await pineTS.run(pineScript)

console.log('Bars processed:', ctx.marketData.length)
console.log('Plots:', Object.keys(ctx.plots).join(', '))

for (const [name, plot] of Object.entries(ctx.plots)) {
  const lastPoint = plot.data?.[plot.data.length - 1]
  if (lastPoint) {
    console.log(`  ${name}: last value = ${lastPoint.value}`)
  }
}

ctx.plots has every named plot from the indicator. For DeltaPulse Wave that’s the wave line, baseline, OB/OS thresholds, and the divergence shapes. Each one is an array indexed by bar. Grab lastPoint.value and you’ve got the current reading ready for your signal logic.

Live Streaming with pineTS.stream()

Now this is where it gets fun. If you want real-time signals (and let’s be honest, that’s why most of us are here), the streaming API re-evaluates the indicator every time new market data comes in. Zero-line crossover? You’ll know the moment it happens. Divergence signal? Same deal.

// PineTS live streaming example template
import { PineTS, Provider } from 'pinets'
import { readFileSync } from 'node:fs'
import { dirname, join } from 'node:path'
import { fileURLToPath } from 'node:url'

const __dirname = dirname(fileURLToPath(import.meta.url))
const pineScript = readFileSync(join(__dirname, 'source.pine'), 'utf-8')

const pineTS = new PineTS(Provider.Binance, 'BTCUSDC', '1w', 500)

let count = 0
const stream = pineTS.stream(pineScript)

stream.on('data', (ctx) => {
  count++
  console.log(`[Update ${count}] Bars: ${ctx.marketData.length}, Plots: ${Object.keys(ctx.plots).length}`)

  for (const [name, plot] of Object.entries(ctx.plots)) {
    const lastPoint = plot.data?.[plot.data.length - 1]
    if (lastPoint) {
      console.log(`  ${name}: ${lastPoint.value}`)
    }
  }

  if (count >= 5) {
    console.log('Received 5 updates, stopping stream.')
    process.exit(0)
  }
})

stream.on('error', (err) => {
  console.error('Stream error:', err.message)
  process.exit(1)
})

The pineTS.stream(pineScript) call opens a persistent connection to Binance. Every time a candle closes (or updates mid-bar), your callback fires with a fresh execution context. You can check the wave value, look for zero-line crosses, or watch for divergence shapes appearing in the plots. The connection stays open, no polling loop, no manual reinit.

Indicator Properties

Inputs

The inputs split into four groups, and there are more of them than you probably need. The ones worth caring about: waveLen (default 20) sets how many bars the EMAs look back, and smoothLen (default 5) does the final noise reduction pass.

General

InputTypeDefaultDescription
Wave Lookbackint20EMA period for the volume delta calculation. Higher values = smoother, slower wave. I’ve found 20 works great on weekly, but you might want 14 on 4H.
Smoothingint5Second EMA pass on the raw RDS. Lower = more reactive, higher = more lag. Default 5 is a good balance.

Levels

InputTypeDefaultDescription
Upper Threshold (OB)float25.0Overbought zone. When the wave sits above this, buyers are firmly in control.
Lower Threshold (OS)float-25.0Oversold zone. Sellers are dominant. Watch for snap-backs when it hits -40.

Analysis

InputTypeDefaultDescription
Min Divergence Gapint5Minimum bars between peaks before a divergence can fire. This keeps the engine from going trigger-happy on every tiny wiggle.
Show Divergence LinesbooltrueToggles the sync lines connecting price peaks to oscillator peaks. Pretty useful for visual confirmation.

Style & Dashboard

InputTypeDefaultDescription
Aggressive Buyingcolor#00ffbbBullish wave color.
Aggressive Sellingcolor#ff0055Bearish wave color.
Neutral Linecolor#6b7b8fZero baseline and thresholds.
Show DashboardbooltrueToggles the little status table showing current wave, trend, and last divergence.
PositionstringTop RightWhere the dashboard sits (any corner).
SizestringSmallDashboard text size (Tiny through Large).

Plots

Plot NameTypeDescription
DeltaPulse Waveline (linewidth 2)The main oscillator. Green above zero, red below. This is your primary signal.
BaselinelineZero line. Crossovers here = shift between net buying and selling.
OB LevellineUpper threshold (+25 default).
OS LevellineLower threshold (-25 default).
Bull Div Circleshape (circle)Small dot at the bottom of the oscillator when bullish divergence fires.
Bear Div Circleshape (circle)Small dot at the top of the oscillator when bearish divergence fires.
Bullish Divergenceshape (triangleup, overlay)Green “Bull” triangle below the price bar. Hard to miss.
Bearish Divergenceshape (triangledown, overlay)Red “Bear” triangle above the price bar.

A barcolor(waveColor) call also that tints your price bars green or red based on the wave’s direction, plus a gradient fill between the wave and zero that gets more intense as conviction increases. It looks great, and the fill intensity is actually a useful visual cue for how “hot” the volume delta is running.

Alerts

No built-in alertcondition() calls in the source. But honestly, you don’t need them if you’re running through PineTS. Just watch the bullDiv and bearDiv plotshape values in your streaming callback. If you want native TradingView alerts, drop your own alertcondition() lines into the script.

Understanding the Indicator

How the Normalization Actually Works

Okay, this part is actually really smart. ChartPrime’s approach starts with a dead-simple volume classification: if close > open, the entire bar’s volume counts as buying. If close < open, it's selling. Doji bars count for nothing. Yeah, it's a rough approximation, it's not tick-level order flow data. But on 4H+ timeframes, candle body direction correlates pretty well with net aggression, and I've found the signals hold up in practice.

Here's where it gets clever. Instead of just accumulating a running delta that drifts to infinity, the script runs three separate EMAs: one on buy volume, one on sell volume, and one on total volume (all using the same waveLen period of 20 bars). Then it computes (smoothedBuy - smoothedSell) / smoothedTot * 100.

That division by total volume is the key. It locks the output into a bounded percentage range. A reading of +40 means about 70% of recent smoothed volume landed on green candles. Flip to -40, and sellers have that same dominance. One final ta.ema(rdsRaw, smoothLen) pass with the default 5-bar period smooths out the noise, and you've got yourself a double-smoothed, normalized oscillator that stays between -50 and +50 no matter if the asset trades $1M or $1B per day.

I love that design choice, because it means you can genuinely compare readings across assets without recalibrating anything.

The Divergence Engine

DeltaPulse Wave's divergence engine is what separates it from a dozen similar oscillators. Peak detection uses a three-bar pattern: the middle bar has to be higher (or lower) than both its neighbors. But there's a threshold gate, a peak only counts if it's above obThreshold * 0.2 (so above +5 with defaults). Troughs need to be below -5. This kills the garbage signals from tiny wiggles around the zero line.

When a new peak gets detected, it's compared against the previous one. Price made a higher high but the wave made a lower high? That's a bearish divergence: price is climbing but volume conviction is fading. The mirror pattern (price lower low, wave higher low) triggers a bullish divergence. Both sides enforce the minGap requirement of 5 bars minimum between peaks, which prevents the engine from spamming signals on every minor swing.

Smart.

Confirmed divergences show up as sync lines across both panes (the price chart gets them via force_overlay), and triangles labeled "Bull" or "Bear" land right on the price bars themselves. You can monitor divergences from the main chart alone without ever glancing at the oscillator.

The Dashboard

On the last bar, a compact table pops up showing three things: the current wave value (two decimal places), the trend direction (bullish if above zero, bearish below), and the most recent divergence type. It's built with Pine Script's table functions and only fires on barstate.islast, so it doesn't slow down historical processing. You can drag it to any corner and resize it. Not essential for algo work, but nice to have when you're visually reviewing signals.

Using It for Algorithmic Signal Generation

Alright, here's the practical stuff. If I'm building a bot around DeltaPulse Wave, the zero-line crossover combined with threshold context is the most reliable entry signal. Go long when the wave crosses above zero and the previous reading was below -10 (so you know it's a real swing from oversold territory, not just noise bouncing around the baseline). Reverse or close when it drops below zero from above +10.

I wouldn't use the divergence signals as standalone entries though. They're much better as filters. When your trend-following system says "go long," check if a bearish divergence fired in the last 10-15 bars. If it did, maybe skip that trade or cut the size in half. Volume conviction is fading, and you'd rather not chase. On the flip side, a bullish divergence near a support level? That adds real confidence to a long entry.

The extreme readings are where mean-reversion setups live. Anything above +40 or below -40 tends to snap back toward zero. Combine that with a divergence signal and you've got a pretty solid reversal setup. I've seen this work well on 4H and weekly BTCUSDC. On 1-minute charts? Forget about it. The candle-body volume classification is way too noisy at that scale.

Performance Notes

Computation overhead is negligible. Two EMA passes on volume data, one on the result, a handful of comparisons for divergence detection. You won't hit any bottlenecks running this on large bar counts.

One thing to watch out for: divergence signals are confirmed one bar late. The three-bar peak pattern needs the bar after the peak to confirm the turnaround, and all plotshapes use offset = -1 so they visually appear on the correct bar. But in your streaming callback, the signal shows up after the peak bar has already closed. On a weekly chart, that's a one-week delay. Fine for position trading, but keep it in mind if you're on shorter timeframes.

The volume classification is purely candle-body-based, not tick data. Works great on daily and weekly charts. On 5-minute bars, not so much. Real high-frequency delta analysis needs actual tick data, and this indicator is not that tool.

Important Notes

DeltaPulse Wave drops into PineTS without any changes to the source. All 13 plots come through, overlays included. The dashboard table only fires on barstate.islast, so you'll see it on the final bar of the execution context but not in historical data.

One dependency to keep in mind: this indicator needs volume data. Binance pairs through PineTS have it, no worries there. Swap to a provider without volume data and everything quietly collapses to zero (since buyVol and sellVol both pull from the volume built-in). No error, no warning, just flat-lined output. Ask me how I found that out.

The force_overlay = true on the divergence triangles and sync lines means they draw on the price chart even though the indicator lives in a separate pane. In PineTS, these overlay elements show up as plot data alongside the oscillator plots in your execution context.

Disclaimer

QuantForge publishes technical material about indicators: what they do, how they are built, and how you can experiment with them in code and on charts. All of this is offered for education and illustration only. It is not financial, investment, or trading advice, and it should not be read as a recommendation to buy, sell, or hold any asset. Past or simulated performance does not guarantee future results. You are responsible for your own decisions; seek independent professional advice where appropriate.