Use DDD_

A benchmark layer, not another raw feed

Raw stablecoin supply and U.S. M2 are both public, and both stay useful on their own. DDD's job is what sits above them: normalizing those public sources into one maintained number — the USD stablecoin-to-M2 benchmark for on-chain dollar penetration — with a fixed rounding/display rule, historical records, and Tape context behind it.

Stitching DeFiLlama and FRED together yourself means re-deriving the methodology and re-checking the rounding rule every time something changes upstream. DDD carries that maintenance burden so a product, market, widget, article, or dashboard can cite one number instead of re-deriving it.

API usage

The DDD HTTP API returns the same normalized benchmark and Tape outputs used on the site, so you don't need to fetch raw stablecoin or M2 data and re-derive the ratio yourself. Use GET /api/ratio for the current benchmark, and use GET /api/tape for official Tape snapshots and movement windows.

Attribution guidance

When displaying DDD data, cite Digital Dollar Dominance and include the relevant timestamp when available. For benchmark methodology, link to /methodology. For Tape movement data, link to /tape and use expanded/contracted/snapshot-delta language unless event-level evidence is shown. Because the rounding rule and display format are fixed, a DDD citation stays consistent even as the raw source data underneath it updates.

Node.js / GitHub Packages

The @snowplow1337/ddd-oracle-sdk package handles account deserialization. Peer dependency on @solana/web3.js.

// Read the DDD ratio from Solana mainnet
import('@snowplow1337/ddd-oracle-sdk').then(async ({ readDDD }) => {
  const { Connection } = await import('@solana/web3.js');
  const conn = new Connection('https://api.mainnet-beta.solana.com');

  const s = await readDDD(conn);

  console.log('DDD     = ', s.dddPercent.toFixed(4) + '%');
  console.log('Stables = $' + (Number(s.totalStablesUsd) / 1e9).toFixed(2) + 'B');
});

JSON for tools & bots

Versioned read-only endpoints backed by the same on-chain accounts as the SDK. Big integers are returned as strings. Send If-None-Match with the previous ETag to receive 304 Not Modified when the oracle sequence is unchanged.

• GET /api/v1/oracle/snapshot — summary plus chain, issuer, and token books (one Solana multi-account read). Includes consistent; if false, retry later.
• GET /api/v1/oracle/summary — headline summary only (cheapest).
• GET /api/jupiter-solana-route — read-only Jupiter swap/v1 quote (no swap). Query: inputMint, outputMint, optional amount (raw units; default 1000000 when inputMint is USDC), slippageBps. Optional env JUPITER_API_KEY for higher Jupiter limits.

Production: set SOLANA_RPC_URL in Netlify to your RPC provider. Optional ?debug=1 adds non-sensitive metadata.

Python (stdlib only)

No packages required — uses only Python's standard library to query the Solana JSON-RPC and decode the binary account layout directly.

import urllib.request, json, base64, struct
from datetime import datetime, timezone

# Base58 encoder (no deps)
ALPH = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
def b58(b):
    n = int.from_bytes(b, 'big'); s = ''
    while n: n, r = divmod(n, 58); s = ALPH[r] + s
    return '1' * (len(b) - len(b.lstrip(b'\x00'))) + s

# Fetch all 4 oracle accounts in one RPC call
req = urllib.request.Request(
    'https://api.mainnet-beta.solana.com',
    data=json.dumps({
        "jsonrpc": "2.0", "id": 1, "method": "getMultipleAccounts",
        "params": [[
            "8DAncbbsEkmsCCakHpNK5zf49XLcWQrryTBYdjgcLWxA",  # summary
            "97g36T1PV3anxCwxV6ue5MmF2A9HQHMsLqevckrkqjzK", # chains
            "GznG6pxbLPrqeYDd5aFXJcXK5SQ4wXifBtqjep34DNe",  # issuers
            "7FRjdiN489qMU2R8G2RumBPxRjanY9683gnXttKP4Fhv",  # tokens
        ], {"encoding": "base64"}],
    }).encode(),
    headers={'Content-Type': 'application/json'},
)
r = json.loads(urllib.request.urlopen(req).read())['result']['value']
s, c, ib, t = (base64.b64decode(a['data'][0]) for a in r)
ts_utc = lambda u: datetime.fromtimestamp(u, tz=timezone.utc).isoformat()

# Summary account layout (offset 73): ddd, stables, m2, ts, slot, seq
ddd, stb, m2, ts, slot, seq = struct.unpack_from('<QQQqQQ', s, 73)

print(f"DDD ratio : {ddd/1e4:.4f}%")
print(f"Stables   : ${stb/1e9:,.4f}B")
print(f"U.S. M2   : ${m2/1e12:,.4f}T")
print(f"Updated   : {ts_utc(ts)}  (slot {slot:,})")
print(f"Sequence  : {seq}")
print(f"Admin     : {b58(s[8:40])}")

# Book accounts: chains, issuers, tokens
def read_book(name, d):
    cnt = d[25]
    print(f"\n--- {name}  (count={cnt}) ---")
    for k in range(cnt):
        o = 26 + k*29
        nm = d[o+1:o+1+d[o]].decode('utf-8', errors='replace')
        sup, pct = struct.unpack_from('<QI', d, o+17)
        print(f"  {k+1:<3} {nm:<16} ${sup/1e9:>10,.2f}B  {pct/1e6:.4f}%")

read_book('CHAINS',  c)
read_book('ISSUERS', ib)
read_book('TOKENS',  t)

Program & Account Addresses

The oracle writes to four accounts. Read any of them directly via getAccountInfo or getMultipleAccounts.

Direct JSON-RPC Call

No SDK? Fetch the summary account directly with a standard Solana JSON-RPC call. Works with any HTTP client in any language.

$ curl -sS https://api.mainnet-beta.solana.com \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getAccountInfo",
    "params": [
      "8DAncbbsEkmsCCakHpNK5zf49XLcWQrryTBYdjgcLWxA",
      { "encoding": "base64", "commitment": "confirmed" }
    ]
  }'

A successful response is not meant to be human-readable at a glance. The RPC returns JSON; inside it, result.value.data[0] is a base64-encoded binary account (the oracle’s on-chain layout). Solana does not turn that into “DDD = 1.39%” for you — you decode base64, then read little-endian fields starting at byte 73 (see the layout table below). The giant string that looks like gibberish is normal.

If a python3 -c "…" example printed nothing: double quotes make bash/zsh expand $ inside Python f-strings before Python runs. Use the version below with single-quoted -c '…' so stdin from curl still reaches Python (do not use curl | python3 <<'PY' — that replaces stdin and breaks the pipe).

$ curl -sS 'https://api.mainnet-beta.solana.com' -X POST \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"getAccountInfo","params":["8DAncbbsEkmsCCakHpNK5zf49XLcWQrryTBYdjgcLWxA",{"encoding":"base64","commitment":"confirmed"}]}' \
| python3 -c '
import sys, json, base64, struct
from datetime import datetime, timezone
j = json.load(sys.stdin)
b64 = j["result"]["value"]["data"][0]
raw = base64.b64decode(b64)
ddd, stb, m2, ts, slot, seq = struct.unpack_from("<QQQqQQ", raw, 73)
print("DDD %     ", round(ddd / 1e4, 4))
print("Stables   ", "${:.2f}B".format(stb / 1e9))
print("U.S. M2   ", "${:.2f}T".format(m2 / 1e12))
print("Updated   ", datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d %H:%M UTC"))
print("Slot      ", slot)
print("Sequence  ", seq)
'

Summary Account Layout

The summary account is a packed binary struct. All integers are little-endian. The DDD ratio and supply figures start at byte offset 73.

readDDD() Return Fields

The GitHub Packages SDK returns a parsed object. All bigint fields are raw on-chain values.

Usage Notes

• · Update frequency: the oracle is updated daily from DeFiLlama's stablecoin supply data and the Federal Reserve's M2 release. DDD normalizes both into one ratio, applies the fixed rounding/display rule, and writes a versioned snapshot — the published number doesn't drift just because a raw input changes shape upstream.
• · Stale detection: compare sequence numbers across the summary and book accounts. A mismatch flags a mid-write read.
• · No fees: reading Solana accounts is free. You only pay lamports if you write transactions — which you won't need just to read the ratio.
• · RPC endpoint: all code snippets above use the public cluster api.mainnet-beta.solana.com. The green live terminal below uses a dedicated endpoint so browser reads stay reliable; use your own provider in production.

Using DDD with AI Agents

Humans often choose stablecoins based on preference, habit, brand trust or chain loyalty. Agents should use live data. DDD Oracle gives agents machine readable stablecoin signals, including the USD stablecoin-to-M2 benchmark, issuer concentration and chain distribution.

DDD decides. Execution providers execute.

Embed the live stablecoin tracker

Add the live DDD Stablecoin-to-M2 Ratio to any page. Real-time data from the DDD API on each load, no API key, free to use.