RMRK Moonbeam recovery ledger at block 16,672,926

export-moonbeam-recovery-ledger.ts

import { mkdir } from "node:fs/promises";
import path from "node:path";

const TOKEN = "0x524d524b4c9366be706d3a90dcf70076ca037ae3";
const GUARDIAN = "0xf7c5ebbb2905a2ded9a569ba56bef24b57bbc022";
const BURN_ADDRESS = "0x000000000000000000000000000000000000dead";
const SNAPSHOT_BLOCK = 16_672_926n;
const SNAPSHOT_BLOCK_HASH = "0xfa2fa0ab17588a11daf59adb9245a3138cadcf78801b7a508c65b0e327b2adec";
const DECIMALS = 18;
const PAGE_SIZE = 100;
const RPC_BATCH_SIZE = 50;
const TRANSFER_TOPIC =
  "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
const REPORT_BASENAME = `moonbeam-rmrk-recovery-${SNAPSHOT_BLOCK}`;

type Holder = { address: string; subscanRaw: bigint };
type SnapshotHolder = Holder & { amountRaw: bigint; isContract: boolean };
type RpcCall = { method: string; params: unknown[] };

const rpcUrl =
  process.env.MOONBEAM_RPC_URL?.trim() ||
  process.env.ANKR_MOONBEAM_RPC?.trim() ||
  "https://rpc.api.moonbeam.network";
const subscanKey = process.env.SUBSCAN_KEY?.trim();
if (!subscanKey) throw new Error("Missing SUBSCAN_KEY");

const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
const hexBlock = (value: bigint) => `0x${value.toString(16)}`;
const fixed = (value: bigint) =>
  `${value / 10n ** 18n}.${(value % 10n ** 18n).toString().padStart(DECIMALS, "0")}`;
const sum = (values: bigint[]) => values.reduce((total, value) => total + value, 0n);
const balanceOfData = (address: string) =>
  `0x70a08231${address.slice(2).padStart(64, "0")}`;

async function fetchWithRetry(url: string, init: RequestInit, label: string) {
  for (let attempt = 1; attempt <= 5; attempt++) {
    const response = await fetch(url, init);
    if (response.ok) return response;
    if (attempt === 5 || (response.status !== 429 && response.status < 500)) {
      throw new Error(`${label} failed with HTTP ${response.status}`);
    }
    await sleep(attempt * 1_000);
  }
  throw new Error(`${label} failed`);
}

let nextSubscanRequestAt = 0;
async function subscanHolders(page: number) {
  const wait = nextSubscanRequestAt - Date.now();
  if (wait > 0) await sleep(wait);
  const response = await fetchWithRetry(
    "https://moonbeam.api.subscan.io/api/scan/evm/token/holders",
    {
      method: "POST",
      headers: { "content-type": "application/json", "x-api-key": subscanKey! },
      body: JSON.stringify({ contract: TOKEN, page, row: PAGE_SIZE }),
    },
    `Subscan holders page ${page}`,
  );
  nextSubscanRequestAt = Date.now() + 1_000;
  const json = (await response.json()) as {
    code: number;
    message?: string;
    data?: { count: number; list: Array<{ holder: string; balance: string }> };
  };
  if (json.code !== 0 || !json.data) {
    throw new Error(`Subscan page ${page}: ${json.message ?? "invalid response"}`);
  }
  return json.data;
}

async function rpcBatch(calls: RpcCall[]) {
  const payload = calls.map((call, index) => ({
    jsonrpc: "2.0",
    id: index + 1,
    ...call,
  }));
  const response = await fetchWithRetry(
    rpcUrl,
    {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify(payload),
    },
    "Moonbeam RPC batch",
  );
  const json = (await response.json()) as Array<{
    id: number;
    result?: unknown;
    error?: { message: string };
  }>;
  if (!Array.isArray(json)) throw new Error("Moonbeam RPC did not return a batch");
  const byId = new Map(json.map((item) => [item.id, item]));
  return payload.map(({ id }) => {
    const item = byId.get(id);
    if (!item || item.error || item.result === undefined) {
      throw new Error(`Moonbeam RPC call ${id}: ${item?.error?.message ?? "missing result"}`);
    }
    return item.result;
  });
}

async function rpc(method: string, params: unknown[]) {
  return (await rpcBatch([{ method, params }]))[0];
}

async function fetchAllHolders() {
  const first = await subscanHolders(0);
  const pages = Math.ceil(first.count / PAGE_SIZE);
  const list = [...first.list];
  for (let page = 1; page < pages; page++) {
    list.push(...(await subscanHolders(page)).list);
  }
  const holders = list.map(({ holder, balance }): Holder => {
    const address = holder.toLowerCase();
    if (!/^0x[0-9a-f]{40}$/.test(address) || !/^\d+$/.test(balance)) {
      throw new Error(`Invalid holder row: ${holder}, ${balance}`);
    }
    return { address, subscanRaw: BigInt(balance) };
  });
  if (holders.length !== first.count || new Set(holders.map(({ address }) => address)).size !== holders.length) {
    throw new Error(`Expected ${first.count} unique holders, received ${holders.length}`);
  }
  return holders.sort((a, b) => a.address.localeCompare(b.address));
}

async function assertNoTransfersAfterSnapshot(latestBlock: bigint) {
  let transferCount = 0;
  for (let from = SNAPSHOT_BLOCK + 1n; from <= latestBlock; from += 1_024n) {
    const to = from + 1_023n > latestBlock ? latestBlock : from + 1_023n;
    const logs = await rpc("eth_getLogs", [
      {
        address: TOKEN,
        fromBlock: hexBlock(from),
        toBlock: hexBlock(to),
        topics: [TRANSFER_TOPIC],
      },
    ]);
    if (!Array.isArray(logs)) throw new Error("Moonbeam RPC returned invalid logs");
    transferCount += logs.length;
  }
  if (transferCount !== 0) {
    throw new Error(`${transferCount} RMRK transfers occurred after snapshot block`);
  }
}

async function snapshotHolders(holders: Holder[]) {
  const result: SnapshotHolder[] = [];
  for (let offset = 0; offset < holders.length; offset += RPC_BATCH_SIZE) {
    const batch = holders.slice(offset, offset + RPC_BATCH_SIZE);
    const calls = batch.flatMap(({ address }): RpcCall[] => [
      {
        method: "eth_call",
        params: [{ to: TOKEN, data: balanceOfData(address) }, hexBlock(SNAPSHOT_BLOCK)],
      },
      { method: "eth_getCode", params: [address, hexBlock(SNAPSHOT_BLOCK)] },
    ]);
    const values = await rpcBatch(calls);
    batch.forEach((holder, index) => {
      const amountRaw = BigInt(values[index * 2] as string);
      const code = values[index * 2 + 1] as string;
      if (amountRaw !== holder.subscanRaw) {
        throw new Error(`Current/snapshot balance mismatch for ${holder.address}`);
      }
      result.push({ ...holder, amountRaw, isContract: code !== "0x" });
    });
    await sleep(250);
  }
  return result;
}

const holders = await fetchAllHolders();
if (holders.length !== 3_779) throw new Error(`Expected 3,779 holders, received ${holders.length}`);

const block = (await rpc("eth_getBlockByNumber", [hexBlock(SNAPSHOT_BLOCK), false])) as {
  hash: string;
  number: string;
  timestamp: string;
};
if (BigInt(block.number) !== SNAPSHOT_BLOCK || block.hash.toLowerCase() !== SNAPSHOT_BLOCK_HASH) {
  throw new Error(`Snapshot block hash mismatch: ${block.hash}`);
}
const finalized = (await rpc("eth_getBlockByNumber", ["finalized", false])) as {
  hash: string;
  number: string;
  timestamp: string;
};
const finalizedBlock = BigInt(finalized.number);
if (finalizedBlock < SNAPSHOT_BLOCK) {
  throw new Error(`Finalized head ${finalizedBlock} is older than the snapshot`);
}
await assertNoTransfersAfterSnapshot(finalizedBlock);
const snapshot = await snapshotHolders(holders);
const totalSupplyRaw = BigInt(
  (await rpc("eth_call", [{ to: TOKEN, data: "0x18160ddd" }, hexBlock(SNAPSHOT_BLOCK)])) as string,
);
const verifiedBlock = (await rpc("eth_getBlockByNumber", [hexBlock(SNAPSHOT_BLOCK), false])) as {
  hash: string;
};
if (verifiedBlock.hash.toLowerCase() !== SNAPSHOT_BLOCK_HASH) {
  throw new Error(`Snapshot block changed during export: ${verifiedBlock.hash}`);
}

if (sum(snapshot.map(({ amountRaw }) => amountRaw)) !== totalSupplyRaw) {
  throw new Error("Holder balances do not reconcile to totalSupply");
}

const guardian = snapshot.find(({ address }) => address === GUARDIAN);
if (!guardian?.isContract) throw new Error("Guardian missing or not classified as a contract");
const burned = snapshot.find(({ address }) => address === BURN_ADDRESS);
if (!burned || burned.isContract) throw new Error("Burn address missing or classified as a contract");

const contracts = snapshot.filter(({ address, isContract }) => isContract && address !== GUARDIAN);
const eligible = snapshot.filter(
  ({ address, isContract }) => !isContract && address !== GUARDIAN && address !== BURN_ADDRESS,
);
if (contracts.length !== 12 || eligible.length !== 3_765) {
  throw new Error(`Expected 12 contracts and 3,765 claimable EOAs; received ${contracts.length} and ${eligible.length}`);
}

const rows = eligible.map(({ address, amountRaw }) => ({
  address,
  amountRaw,
  receivingRaw: (amountRaw * 95n) / 100n,
}));
const csv = [
  "address,amount,receiving_amount",
  ...rows.map(({ address, amountRaw, receivingRaw }) =>
    [address, fixed(amountRaw), fixed(receivingRaw)].join(","),
  ),
].join("\n") + "\n";
const csvSha256 = new Bun.CryptoHasher("sha256").update(csv).digest("hex");

const eligibleAmountRaw = sum(rows.map(({ amountRaw }) => amountRaw));
const receivingAmountRaw = sum(rows.map(({ receivingRaw }) => receivingRaw));
const metadata = {
  chain: "Moonbeam",
  token: TOKEN,
  snapshot_block: Number(SNAPSHOT_BLOCK),
  snapshot_block_hash: SNAPSHOT_BLOCK_HASH,
  snapshot_timestamp_utc: new Date(Number(BigInt(block.timestamp)) * 1_000).toISOString(),
  finalized_verified_block: Number(finalizedBlock),
  finalized_verified_block_hash: finalized.hash,
  finalized_verified_timestamp_utc: new Date(Number(BigInt(finalized.timestamp)) * 1_000).toISOString(),
  post_snapshot_transfer_count: 0,
  indexed_holder_count: holders.length,
  excluded_guardian: {
    address: GUARDIAN,
    amount: fixed(guardian.amountRaw),
  },
  excluded_burn_address: {
    address: BURN_ADDRESS,
    amount: fixed(burned.amountRaw),
  },
  excluded_contract_count: contracts.length,
  excluded_contract_amount: fixed(sum(contracts.map(({ amountRaw }) => amountRaw))),
  excluded_contracts: contracts.map(({ address, amountRaw }) => ({
    address,
    amount: fixed(amountRaw),
  })),
  eligible_eoa_count: rows.length,
  total_supply: fixed(totalSupplyRaw),
  canonical_supply_excluding_guardian: fixed(totalSupplyRaw - guardian.amountRaw),
  eligible_eoa_amount: fixed(eligibleAmountRaw),
  receiving_amount_after_5_percent_fee: fixed(receivingAmountRaw),
  fee_amount: fixed(eligibleAmountRaw - receivingAmountRaw),
  receiving_formula: "floor(amount_raw * 95 / 100), calculated per address",
  csv_sort: "lowercase address ascending",
  csv_line_endings: "LF",
  csv_sha256: csvSha256,
};

const reportDir = path.join(import.meta.dir, "..", "reports");
await mkdir(reportDir, { recursive: true });
await Bun.write(path.join(reportDir, `${REPORT_BASENAME}.csv`), csv);
await Bun.write(
  path.join(reportDir, `${REPORT_BASENAME}.metadata.json`),
  `${JSON.stringify(metadata, null, 2)}\n`,
);
console.log(JSON.stringify(metadata, null, 2));

moonbeam-rmrk-recovery-16672926.csv

moonbeam-rmrk-recovery-16672926.md

RMRK Moonbeam recovery ledger

This ledger freezes the final pre-maintenance RMRK balances that are eligible for a one-time Base replacement, after the existing 5% late-claim fee.

Snapshot

• Chain: Moonbeam
• Token: 0x524d524b4c9366be706d3a90dcf70076ca037ae3
• Block: 16,672,926
• Block hash: 0xfa2fa0ab17588a11daf59adb9245a3138cadcf78801b7a508c65b0e327b2adec
• Timestamp: 2026-08-01 00:01:24 UTC
• Indexed holders: 3,779
• Post-snapshot RMRK transfers through finalized block 16,679,075: 0

Exclusions

• Overmint Guardian: 6,151,846.417175420000000000 RMRK
• Burn address 0x000000000000000000000000000000000000dead: 0.100000000000000000 RMRK
• Other contract holders: 12
• RMRK held by those 12 contracts: 752.600105598943052169 RMRK

The Guardian, burn address, and all 12 other contract holders are omitted from the payout CSV. The CSV contains the remaining 3,765 claimable EOAs.

Totals

• Canonical Moonbeam supply excluding the Guardian: 1,712,738.826352475147471905 RMRK
• Eligible EOA amount before fee: 1,711,986.126246876204419736 RMRK
• Receiving amount after fee: 1,626,386.819934532394197868 RMRK
• Fee amount including per-row wei rounding: 85,599.306312343810221868 RMRK

receiving_amount is calculated independently for each address as floor(amount_raw × 95 ÷ 100). Amounts use exactly 18 decimals, addresses are lowercase and sorted ascending, line endings are LF, and the file ends with one newline.

Integrity

• CSV SHA-256: cddb7f5a493b5d081ce27c5ce2bde63dc4c43e1fc907a3dff2781b6bc459e2f7

The exporter enumerates all holders through Subscan, verifies that every indexed balance equals balanceOf at the snapshot block, classifies each address with eth_getCode at that block, reconciles all balances to totalSupply, and confirms that no later RMRK Transfer event occurred.

Subscan is used only for the initial address enumeration. The versioned Gist files are the frozen source evidence: the payout CSV plus metadata account for all 3,779 snapshot holders, including every exclusion. A future Subscan result is not authoritative for this ledger.

Double-recovery boundary

This file freezes maximum one-time replacement entitlements; it does not mark any row as paid. A separate append-only claims ledger must record each fulfilled entitlement.

An address denylist is not sufficient if Moonbeam reopens: a holder could transfer legacy RMRK to a fresh address. Before any replacement payout, Moonbeam RMRK must be disabled globally as a source for every official bridge or migration path. Legacy Moonbeam tokens must remain noncanonical unless they are first burned or locked.

moonbeam-rmrk-recovery-16672926.metadata.json

{
  "chain": "Moonbeam",
  "token": "0x524d524b4c9366be706d3a90dcf70076ca037ae3",
  "snapshot_block": 16672926,
  "snapshot_block_hash": "0xfa2fa0ab17588a11daf59adb9245a3138cadcf78801b7a508c65b0e327b2adec",
  "snapshot_timestamp_utc": "2026-08-01T00:01:24.000Z",
  "finalized_verified_block": 16679075,
  "finalized_verified_block_hash": "0x0f2c537a7df48e21dd315f6e87effab43786d6eb544eb38858752b491d8ee0ed",
  "finalized_verified_timestamp_utc": "2026-08-01T10:27:12.000Z",
  "post_snapshot_transfer_count": 0,
  "indexed_holder_count": 3779,
  "excluded_guardian": {
    "address": "0xf7c5ebbb2905a2ded9a569ba56bef24b57bbc022",
    "amount": "6151846.417175420000000000"
  },
  "excluded_burn_address": {
    "address": "0x000000000000000000000000000000000000dead",
    "amount": "0.100000000000000000"
  },
  "excluded_contract_count": 12,
  "excluded_contract_amount": "752.600105598943052169",
  "excluded_contracts": [
    {
      "address": "0x000092abed8b6b86686834c6818e27ab9a6b0000",
      "amount": "7.214562018900000000"
    },
    {
      "address": "0x02caaa46b77ae1fd7246cd6bda0e41c67398fecd",
      "amount": "0.067965428582171603"
    },
    {
      "address": "0x287081fc4cba0f48b126991105775b3fc31f123d",
      "amount": "0.000000000000000008"
    },
    {
      "address": "0x294f8bbc95cde6945349f4be6e003e8b4cb73777",
      "amount": "0.020000000000000000"
    },
    {
      "address": "0x524d524b4c9366be706d3a90dcf70076ca037ae3",
      "amount": "391.349578151460878900"
    },
    {
      "address": "0x583af38702c2a53619558acbc758a77d0c0918e9",
      "amount": "2.000000000000001655"
    },
    {
      "address": "0x832b21fa3aa074ee5328f653d9db147bcb155c7a",
      "amount": "0.000000000000000001"
    },
    {
      "address": "0x85ab410a50a3d85f1a26d9e4efcaa520a39b9cd6",
      "amount": "100.000000000000000000"
    },
    {
      "address": "0xad6cea45f98444a922a2b4fe96b8c90f0862d2f4",
      "amount": "0.000000000000000001"
    },
    {
      "address": "0xb1731c586ca89a23809861c6103f0b96b3f57d92",
      "amount": "51.948000000000000000"
    },
    {
      "address": "0xea749fd6ba492dbc14c24fe8a3d08769229b896c",
      "amount": "0.000000000000000001"
    },
    {
      "address": "0xf13221e8e31a4a33c812937404b5c943c1094f0d",
      "amount": "200.000000000000000000"
    }
  ],
  "eligible_eoa_count": 3765,
  "total_supply": "7864585.243527895147471905",
  "canonical_supply_excluding_guardian": "1712738.826352475147471905",
  "eligible_eoa_amount": "1711986.126246876204419736",
  "receiving_amount_after_5_percent_fee": "1626386.819934532394197868",
  "fee_amount": "85599.306312343810221868",
  "receiving_formula": "floor(amount_raw * 95 / 100), calculated per address",
  "csv_sort": "lowercase address ascending",
  "csv_line_endings": "LF",
  "csv_sha256": "cddb7f5a493b5d081ce27c5ce2bde63dc4c43e1fc907a3dff2781b6bc459e2f7"
}