DEV Community: Cambixa

Tracking the stablecoin supply drop with 30 lines of Node

Cambixa — Fri, 13 Nov 2026 02:19:49 +0000

Why this number now

On 11 November 2026, Glassnode reported that the supply of major stablecoins fell $14.2 billion over 30 days, the largest 30-day contraction since June 2022 (The Block, Cointelegraph, Crypto Briefing). Stablecoin supply only shrinks when holders redeem tokens with the issuer, so analysts read it as cash leaving the crypto market.

Outlets quoted different totals for the remaining supply: "just below $280 billion" in one, "$290 to $293 billion" in another. I wanted to see the raw series myself, and DefiLlama publishes it for free with no API key.

The script

It uses built-in fetch (Node 18+) and two public endpoints:

https://stablecoins.llama.fi/stablecoincharts/all returns one point per day with totalCirculatingUSD.peggedUSD.
https://stablecoins.llama.fi/stablecoins returns every stablecoin with circulating and circulatingPrevMonth.

// supply-change.mjs
// Usage: node supply-change.mjs [days]
const DAYS = Number(process.argv[2] || 30);
const usd = (n) => `${n < 0 ? '-' : ''}$${(Math.abs(n) / 1e9).toFixed(2)}B`;

// 1. Total supply of USD-pegged stablecoins, one point per day
const chart = await (await fetch('https://stablecoins.llama.fi/stablecoincharts/all')).json();
const total = chart.map((d) => ({
  day: new Date(Number(d.date) * 1000).toISOString().slice(0, 10),
  v: d.totalCirculatingUSD?.peggedUSD ?? 0,
}));
const now = total.at(-1);
const then = total.at(-1 - DAYS);
const pct = ((now.v / then.v - 1) * 100).toFixed(2);
console.log(`Total: ${usd(then.v)} on ${then.day} -> ${usd(now.v)} on ${now.day} (${usd(now.v - then.v)}, ${pct}%)`);

// 2. The six largest USD stablecoins: today vs a month ago
const { peggedAssets } = await (await fetch('https://stablecoins.llama.fi/stablecoins?includePrices=false')).json();
const rows = peggedAssets
  .filter((a) => a.pegType === 'peggedUSD')
  .map((a) => ({ sym: a.symbol, now: a.circulating?.peggedUSD ?? 0, month: a.circulatingPrevMonth?.peggedUSD ?? 0 }))
  .sort((a, b) => b.now - a.now)
  .slice(0, 6);
for (const r of rows) {
  const d = r.now - r.month;
  console.log(`${r.sym.padEnd(6)} ${usd(r.now).padStart(9)}  ${d >= 0 ? '+' : ''}${usd(d)}`);
}

What it printed

I ran it at 01:50 UTC on 13 November 2026:

Total: $303.97B on 2026-10-14 -> $287.71B on 2026-11-13 (-$16.26B, -5.35%)
USDT    $175.48B  -$8.43B
USDC     $69.45B  -$3.69B
USDS      $5.38B  -$1.58B
USDe      $4.90B  +$0.14B
DAI       $4.66B  -$0.08B
USD1      $3.17B  -$1.04B

My window ends three days after Glassnode's and DefiLlama tracks more coins, so -$16.26B versus -$14.2B is expected. The direction matches, and USDT plus USDC make up about $12.1B of the drop, close to the "nearly $11 billion" The Block reported for those two.

Things that tripped me up

date in the chart endpoint is a Unix timestamp in seconds, as a string. Number(d.date) * 1000 before building a Date.
circulatingPrevMonth is a rolling value from DefiLlama's side, so it won't line up with the chart's day-30 point to the cent. Use the chart for the total and the per-coin fields for the breakdown.
Filter on pegType === 'peggedUSD'. Without it, euro and gold tokens end up in your top six.
Different trackers include different coins. That explains most of the disagreement between published totals.

Ideas to extend it

Run it daily from a cron job and alert when the 30-day change flips positive. Glassnode called that the first sign of new money coming in.
Break USDT down by chain with the chainCirculating field to see which networks lost the most.

Sources: Glassnode via The Block (11 Nov 2026), Cointelegraph (12 Nov 2026), Crypto Briefing (11 Nov 2026), DefiLlama stablecoin API.

Measuring Avalanche C-Chain block cadence with 40 lines of Node

Cambixa — Tue, 10 Nov 2026 02:16:07 +0000

Why look at block timing now

On 9 November 2026, Ava Labs said Avalanche will be the core ledger technology for the clearing firm behind NYSE's planned tokenized securities venue, built for 24/7 trading, clearing and settlement pending regulatory approval (Cointelegraph, Decrypt, The Block). NYSE says the stocks can be issued on several chains, while one ledger records and settles the trades.

Settlement speed is the pitch, so I wanted real numbers instead of a marketing figure. The script below asks a public Avalanche C-Chain RPC node for the last N blocks and reports the gaps between their timestamps.

The script

It uses only built-in fetch (Node 18+) and plain JSON-RPC: eth_blockNumber and eth_getBlockByNumber. The C-Chain speaks the Ethereum RPC dialect, so nothing Avalanche-specific is needed.

// block-cadence.mjs
// Usage: node block-cadence.mjs [N] [rpc]
const N = Number(process.argv[2] || 200);
const RPC = process.argv[3] || 'https://api.avax.network/ext/bc/C/rpc';

async function rpc(method, params) {
  const res = await fetch(RPC, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
  });
  const json = await res.json();
  if (json.error) throw new Error(json.error.message);
  return json.result;
}

const head = parseInt(await rpc('eth_blockNumber', []), 16);
const blocks = [];
for (let n = head - N; n <= head; n += 20) {
  const batch = [];
  for (let k = n; k < Math.min(n + 20, head + 1); k++)
    batch.push(rpc('eth_getBlockByNumber', ['0x' + k.toString(16), false]));
  blocks.push(...(await Promise.all(batch)));
}

// newer blocks also carry a millisecond timestamp; fall back to seconds
const ms = (b) => (b.timestampMilliseconds
  ? parseInt(b.timestampMilliseconds, 16)
  : parseInt(b.timestamp, 16) * 1000);

const gaps = [];
for (let i = 1; i < blocks.length; i++) gaps.push(ms(blocks[i]) - ms(blocks[i - 1]));
gaps.sort((a, b) => a - b);
const pct = (p) => gaps[Math.min(gaps.length - 1, Math.floor((p / 100) * gaps.length))];
const span = (ms(blocks.at(-1)) - ms(blocks[0])) / 1000;
const txs = blocks.reduce((s, b) => s + b.transactions.length, 0);

console.log(`C-Chain blocks ${head - N}..${head} (${blocks.length} blocks over ${span.toFixed(1)} s)`);
console.log(`gap between blocks: median ${pct(50)} ms, p90 ${pct(90)} ms, max ${gaps.at(-1)} ms`);
console.log(`transactions: ${txs} (${(txs / span).toFixed(1)} per second)`);

Blocks are fetched in batches of 20 so a free node doesn't rate-limit you, and the gaps are sorted once so percentiles are a simple index.

What it printed

Run at 01:44 UTC on 10 November 2026 against https://avalanche-c-chain-rpc.publicnode.com:

C-Chain blocks 99898214..99898414 (201 blocks over 206.7 s)
gap between blocks: median 700 ms, p90 1729 ms, max 4909 ms
transactions: 651 (3.1 per second)

That was a quiet hour in Europe and the US, so the gaps are probably wider than at peak. Run it a few times across the day before you quote a number.

A networking gotcha

On one Windows machine the first run failed with fetch failed and ETIMEDOUT while curl to the same node worked. Node's happy-eyeballs logic gives each address 250 ms by default, and the IPv6 routes were unreachable. Raising the per-attempt timeout fixed it:

node --network-family-autoselection-attempt-timeout=3000 block-cadence.mjs 200 https://avalanche-c-chain-rpc.publicnode.com

What the numbers don't tell you

A block landing is not the same as a trade being final in the legal sense, and NYSE hasn't said whether its ledger will be the public C-Chain or a dedicated Avalanche chain. Its stated need to control who participates hints at some permissioning. The script measures one public chain at one moment, which is useful for comparing chains or watching a node, and not more than that.

Ideas to extend it

Pass a different RPC URL to compare chains that use the Ethereum dialect.
Log gasUsed / gasLimit per block to see how full blocks are.
Run it on a cron and chart the median over a week.