How Much ETH and ETC Sits Behind Exposed Public Keys

-- Today's ETC supply split by whether the holding address has its public key
-- on-chain, and for exposed keys whether they signed in the last three years.
-- A key is exposed once its address has signed a transaction on ETC, or on
-- Ethereum (same key, same address). Scans about 200 GB, mostly Ethereum.
DECLARE snapshot TIMESTAMP DEFAULT TIMESTAMP('2026-10-08 01:58:10');
DECLARE dormant_before TIMESTAMP DEFAULT TIMESTAMP('2023-10-08 01:58:10');  -- three years earlier

WITH etc_signed AS (                -- last ETC signature per address
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `classix-etc-data.crypto_ethereum_classic.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
eth_signed AS (                     -- last Ethereum signature per address
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `bigquery-public-data.crypto_ethereum.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
contracts AS (                      -- contracts have no key of their own
  SELECT DISTINCT address FROM `classix-etc-data.crypto_ethereum_classic.contracts`
)
SELECT
  CASE
    WHEN c.address IS NOT NULL THEN 'contract'
    WHEN COALESCE(etc.last_signed, eth.last_signed) IS NULL THEN 'never signed'
    WHEN COALESCE(etc.last_signed, eth.last_signed) < dormant_before THEN 'exposed, dormant'
    ELSE 'exposed, active'
  END AS category,
  COUNT(*) AS addresses,
  ROUND(SUM(b.eth_balance) / 1e18) AS etc
FROM `classix-etc-data.crypto_ethereum_classic.balances` AS b
LEFT JOIN etc_signed AS etc USING (address)
LEFT JOIN eth_signed AS eth USING (address)
LEFT JOIN contracts AS c USING (address)
WHERE b.eth_balance > 0
GROUP BY category
ORDER BY etc DESC

-- ETC on exposed keys, by the year each key last signed. Keys that signed on
-- ETC are dated by their last ETC signature, keys exposed only on Ethereum by
-- their last Ethereum signature. Scans about 200 GB, mostly Ethereum.
DECLARE snapshot TIMESTAMP DEFAULT TIMESTAMP('2026-10-08 01:58:10');

WITH etc_signed AS (
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `classix-etc-data.crypto_ethereum_classic.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
eth_signed AS (
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `bigquery-public-data.crypto_ethereum.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
contracts AS (
  SELECT DISTINCT address FROM `classix-etc-data.crypto_ethereum_classic.contracts`
)
SELECT
  EXTRACT(YEAR FROM COALESCE(etc.last_signed, eth.last_signed)) AS last_signed_in,
  COUNT(*) AS addresses,
  ROUND(SUM(b.eth_balance) / 1e18) AS etc
FROM `classix-etc-data.crypto_ethereum_classic.balances` AS b
LEFT JOIN etc_signed AS etc USING (address)
LEFT JOIN eth_signed AS eth USING (address)
LEFT JOIN contracts AS c USING (address)
WHERE b.eth_balance > 0
  AND c.address IS NULL
  AND COALESCE(etc.last_signed, eth.last_signed) IS NOT NULL
GROUP BY last_signed_in
ORDER BY last_signed_in

-- The ten largest balances on keys that signed on ETC in 2025 or 2026.
WITH etc_signed AS (
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `classix-etc-data.crypto_ethereum_classic.transactions`
  WHERE block_timestamp <= TIMESTAMP('2026-10-08 01:58:10')
  GROUP BY address
)
SELECT b.address, ROUND(b.eth_balance / 1e18) AS etc, DATE(s.last_signed) AS last_signed
FROM `classix-etc-data.crypto_ethereum_classic.balances` AS b
JOIN etc_signed AS s USING (address)
WHERE s.last_signed >= TIMESTAMP('2025-01-01')
ORDER BY b.eth_balance DESC
LIMIT 10

-- The ten largest balances on exposed keys that last signed before 2025, on
-- ETC, or on Ethereum for keys that never signed on ETC. Contracts excluded.
-- Scans about 200 GB, mostly Ethereum.
DECLARE snapshot TIMESTAMP DEFAULT TIMESTAMP('2026-10-08 01:58:10');

WITH etc_signed AS (
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `classix-etc-data.crypto_ethereum_classic.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
eth_signed AS (
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `bigquery-public-data.crypto_ethereum.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
contracts AS (
  SELECT DISTINCT address FROM `classix-etc-data.crypto_ethereum_classic.contracts`
)
SELECT
  b.address,
  ROUND(b.eth_balance / 1e18) AS etc,
  DATE(COALESCE(etc.last_signed, eth.last_signed)) AS last_signed,
  IF(etc.address IS NOT NULL, 'ETC', 'Ethereum') AS signed_on
FROM `classix-etc-data.crypto_ethereum_classic.balances` AS b
LEFT JOIN etc_signed AS etc USING (address)
LEFT JOIN eth_signed AS eth USING (address)
LEFT JOIN contracts AS c USING (address)
WHERE c.address IS NULL
  AND COALESCE(etc.last_signed, eth.last_signed) < TIMESTAMP('2025-01-01')
ORDER BY b.eth_balance DESC
LIMIT 10

import { keccak256, parseTransaction, recoverPublicKey, serializeTransaction } from 'viem'
import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'

// A private key is 32 random bytes. Only the owner ever sees it.
const privateKey = generatePrivateKey()
const account = privateKeyToAccount(privateKey)

// The public key comes from the private key by elliptic-curve multiplication
// on secp256k1. Running that backwards is what Shor's algorithm would do.
const publicKey = account.publicKey // 0x04 followed by 64 bytes
// e.g. 0x04976104…9342dff

// The address is the last 20 bytes of the Keccak-256 hash of the public key.
// A hash can't be run backwards, so the address on its own reveals nothing.
const keyBytes = publicKey.replace(/^0x04/, '0x')     // drop the 04 marker, keep the 0x prefix
const address = `0x${keccak256(keyBytes).slice(-40)}` // last 20 bytes of the hash
// e.g. 0x4e5ec33e1e7bd13186e6e0c37127b4f0510f60d7
console.log(address === account.address.toLowerCase()) // true

// Sending ETC means signing a transaction with the private key.
const signed = await account.signTransaction({
  chainId: 61, // Ethereum Classic mainnet
  to: account.address,
  value: 1n,
  nonce: 0,
  gas: 21000n,
  gasPrice: 1_000_000_000n,
})

// Anyone who sees the signed transaction can recover the full public key
// from its signature. That's how every node checks who sent it.
const { r, s, v, yParity, ...unsigned } = parseTransaction(signed)
const recovered = await recoverPublicKey({
  hash: keccak256(serializeTransaction(unsigned)),
  signature: { r: r!, s: s!, yParity: yParity! },
})
console.log(recovered === publicKey) // true

// This is why only addresses that have sent at least one transaction are
// exposed. Until then the chain holds nothing but the hash.

-- Rough size of staked ETH: everything deposited into the beacon deposit
-- contract, minus everything withdrawn back to the execution layer since
-- Shapella. Leaves out rewards earned but not yet withdrawn.
SELECT
  (SELECT SUM(eth_balance) / 1e18 FROM `bigquery-public-data.crypto_ethereum.balances`
   WHERE address = '0x00000000219ab540356cbb839cbe05303d7705fa') AS deposited_eth,
  (SELECT SUM(CAST(w.amount AS NUMERIC)) / 1e9 FROM `bigquery-public-data.crypto_ethereum.blocks`, UNNEST(withdrawals) AS w
   WHERE timestamp <= TIMESTAMP('2026-10-08 01:58:10')) AS withdrawn_eth

-- Ethereum's ETH supply split the same way as the ETC pie. The beacon deposit
-- contract holds every ETH ever staked and is its own row.
DECLARE snapshot TIMESTAMP DEFAULT TIMESTAMP('2026-10-08 01:58:10');
DECLARE dormant_before TIMESTAMP DEFAULT TIMESTAMP('2023-10-08 01:58:10');  -- three years earlier

WITH eth_signed AS (                -- last Ethereum signature per address
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `bigquery-public-data.crypto_ethereum.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
etc_signed AS (                     -- last ETC signature per address (same key)
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `classix-etc-data.crypto_ethereum_classic.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
contracts AS (
  SELECT DISTINCT address FROM `bigquery-public-data.crypto_ethereum.contracts`
),
holders AS (
  SELECT b.address, b.eth_balance,
         COALESCE(eth.last_signed, etc.last_signed) AS last_signed,
         IF(eth.address IS NOT NULL, 'Ethereum', 'ETC') AS signed_on,
         c.address IS NOT NULL AS is_contract
  FROM `bigquery-public-data.crypto_ethereum.balances` AS b
  LEFT JOIN eth_signed AS eth USING (address)
  LEFT JOIN etc_signed AS etc USING (address)
  LEFT JOIN contracts AS c USING (address)
  WHERE b.eth_balance > 0
)
SELECT
  CASE
    WHEN address = '0x00000000219ab540356cbb839cbe05303d7705fa' THEN 'beacon deposit contract'
    WHEN is_contract THEN 'contract'
    WHEN last_signed IS NULL THEN 'never signed'
    WHEN last_signed < dormant_before THEN 'exposed, dormant'
    ELSE 'exposed, active'
  END AS category,
  COUNT(*) AS addresses,
  ROUND(SUM(eth_balance) / 1e18) AS eth
FROM holders
GROUP BY category
ORDER BY eth DESC

-- ETH on exposed keys by the year each key last signed.
DECLARE snapshot TIMESTAMP DEFAULT TIMESTAMP('2026-10-08 01:58:10');
DECLARE dormant_before TIMESTAMP DEFAULT TIMESTAMP('2023-10-08 01:58:10');  -- three years earlier

WITH eth_signed AS (                -- last Ethereum signature per address
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `bigquery-public-data.crypto_ethereum.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
etc_signed AS (                     -- last ETC signature per address (same key)
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `classix-etc-data.crypto_ethereum_classic.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
contracts AS (
  SELECT DISTINCT address FROM `bigquery-public-data.crypto_ethereum.contracts`
),
holders AS (
  SELECT b.address, b.eth_balance,
         COALESCE(eth.last_signed, etc.last_signed) AS last_signed,
         IF(eth.address IS NOT NULL, 'Ethereum', 'ETC') AS signed_on,
         c.address IS NOT NULL AS is_contract
  FROM `bigquery-public-data.crypto_ethereum.balances` AS b
  LEFT JOIN eth_signed AS eth USING (address)
  LEFT JOIN etc_signed AS etc USING (address)
  LEFT JOIN contracts AS c USING (address)
  WHERE b.eth_balance > 0
)
SELECT EXTRACT(YEAR FROM last_signed) AS last_signed_in, COUNT(*) AS addresses,
       ROUND(SUM(eth_balance) / 1e18) AS eth
FROM holders
WHERE NOT is_contract AND last_signed IS NOT NULL
GROUP BY last_signed_in
ORDER BY last_signed_in

-- The ten largest ETH balances on keys that signed in 2025 or 2026.
DECLARE snapshot TIMESTAMP DEFAULT TIMESTAMP('2026-10-08 01:58:10');
DECLARE dormant_before TIMESTAMP DEFAULT TIMESTAMP('2023-10-08 01:58:10');  -- three years earlier

WITH eth_signed AS (                -- last Ethereum signature per address
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `bigquery-public-data.crypto_ethereum.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
etc_signed AS (                     -- last ETC signature per address (same key)
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `classix-etc-data.crypto_ethereum_classic.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
contracts AS (
  SELECT DISTINCT address FROM `bigquery-public-data.crypto_ethereum.contracts`
),
holders AS (
  SELECT b.address, b.eth_balance,
         COALESCE(eth.last_signed, etc.last_signed) AS last_signed,
         IF(eth.address IS NOT NULL, 'Ethereum', 'ETC') AS signed_on,
         c.address IS NOT NULL AS is_contract
  FROM `bigquery-public-data.crypto_ethereum.balances` AS b
  LEFT JOIN eth_signed AS eth USING (address)
  LEFT JOIN etc_signed AS etc USING (address)
  LEFT JOIN contracts AS c USING (address)
  WHERE b.eth_balance > 0
)
SELECT address, ROUND(eth_balance / 1e18) AS eth, DATE(last_signed) AS last_signed, signed_on
FROM holders
WHERE NOT is_contract AND last_signed >= TIMESTAMP('2025-01-01')
ORDER BY eth_balance DESC
LIMIT 25

-- The ten largest ETH balances on exposed keys that last signed before 2025.
DECLARE snapshot TIMESTAMP DEFAULT TIMESTAMP('2026-10-08 01:58:10');
DECLARE dormant_before TIMESTAMP DEFAULT TIMESTAMP('2023-10-08 01:58:10');  -- three years earlier

WITH eth_signed AS (                -- last Ethereum signature per address
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `bigquery-public-data.crypto_ethereum.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
etc_signed AS (                     -- last ETC signature per address (same key)
  SELECT from_address AS address, MAX(block_timestamp) AS last_signed
  FROM `classix-etc-data.crypto_ethereum_classic.transactions`
  WHERE block_timestamp <= snapshot
  GROUP BY address
),
contracts AS (
  SELECT DISTINCT address FROM `bigquery-public-data.crypto_ethereum.contracts`
),
holders AS (
  SELECT b.address, b.eth_balance,
         COALESCE(eth.last_signed, etc.last_signed) AS last_signed,
         IF(eth.address IS NOT NULL, 'Ethereum', 'ETC') AS signed_on,
         c.address IS NOT NULL AS is_contract
  FROM `bigquery-public-data.crypto_ethereum.balances` AS b
  LEFT JOIN eth_signed AS eth USING (address)
  LEFT JOIN etc_signed AS etc USING (address)
  LEFT JOIN contracts AS c USING (address)
  WHERE b.eth_balance > 0
)
SELECT address, ROUND(eth_balance / 1e18) AS eth, DATE(last_signed) AS last_signed, signed_on
FROM holders
WHERE NOT is_contract AND last_signed < TIMESTAMP('2025-01-01')
ORDER BY eth_balance DESC
LIMIT 25