Today we’re sharing difficult news.

After a hard review of Powerloom’s path forward, I and Swaroop have decided to wind down Powerloom.

This is not the outcome we wanted. Powerloom began with a clear belief: that onchain applications should have access to reliable, verifiable, decentralized data infrastructure. Over the years, the team and community helped bring that vision through multiple phases—testnet, mainnet, snapshotter participation, data markets, validator infrastructure, and developer-facing products.

It is a bittersweet goodbye for both of us founders, and hopefully for some of the friends we made along the way. It hurts to let go of something we have dedicated the last half decade to building, born out of distilled insights and unbridled curiosity in late 2020, formalized and fueled by the preceding two years of incessant building on EVM, Solidity, and the early Wild West frontiers of dApp development.

But building infrastructure is not only a technical challenge. It also requires a sustainable operating model, continued ecosystem demand, and the resources to support operators, developers, users, and the network over the long term. After reviewing our options, we do not believe it is responsible to continue operating Powerloom as though that path still exists.

For further context:

• For the last 8+ months,
  • neither founder has drawn compensation from the Foundation.
  • most of the development, research, troubleshooting, and vigilance required for continued operations of the chain and accessory services have been supported from our personal funds.
• This allowed us to go live with the Decentralized Sequencer-Validator (DSV) network, the BDS data market, and the agentic consumption systems built on and around them. But this is as far as we can humanly stretch our resources and energy.

So we are choosing an orderly wind-down.

What happens next

We are following an orderly wind-down with published dates for every milestone. The full timeline, with status updates as each step is completed, is maintained on our docs site:

Wind-Down Timeline →

If you have questions, see the FAQ →.

Node operators and builders should read the relevant sections below carefully before making any infrastructure, claim, or migration decisions.

For node operators and stakers

We know many of you contributed real time, attention, infrastructure, and trust to Powerloom.

Your work helped make the network possible. We are grateful for that, and we want the shutdown process to be as clear as possible.

In short: stop your node, claim your rewards, burn your node to recover your tokens, unstake your POWER, and bridge everything out of Powerloom Mainnet via bridge-v2.powerloom.network. Node burns and unstaking withdrawals are immediate, with no cooldown.

Do this before mint.powerloom.network goes offline on July 16, 2026 at 6:00 AM UTC, and bridge to Ethereum before the chain shuts down on July 21, 2026 at 6:00 AM UTC.

The full step-by-step checklist, with the exact CLI command to stop your node and the dashboard actions to claim, burn, and unstake, is here:

Wind-down checklist for node operators and stakers →

Related pages:

• Snapshotter Rewards →: the epoch release cutoff and how to stop your node.
• Reward Claims →: claim your pending rewards.
• Staked POWER →: unstake and withdraw, both immediate.

For DSV validator operators

You have been running validator nodes for 104 days, keeping the DSV network alive in production and helping prove that decentralized sequencing works. Thank you for believing in what we were building.

Here's what you need to know:

• Turn off your validator after June 16, 2026 at 12:00 noon UTC. That is when epoch release stops. After that, no further submissions are expected and there is no penalty for going offline.
• Burn your node to recover your funds. No cooldown. Do it before the Powerloom chain shuts down on July 21, 2026.
• Pending validator rewards (days 91–104) will be distributed within the next 48 hours. These will be sent directly to your node owner address.

Full details: DSV Validator Nodes →

Thank you for helping build DSV and for believing in us in the harder times.

For builders, users, and partners

Powerloom services will remain available during the wind-down period as per the Wind-Down Timeline.

• APIs, BDS & Hosted Services →: per-service sunset dates for the BDS data market, resolver node, metering service, MCP endpoints, agents, and REST/GraphQL APIs.
• Docs & GitHub Repositories →: archival timeline for documentation and open-source repositories.
• Contracts, Bridges & On-chain Components →: what happens to on-chain contracts, the bridge, sequencer, and validators.

Team tokens

All team-held tokens have been burned

Transaction

Security warning

There will be no surprise airdrop, emergency migration, private claim link, or unofficial support account. Please be careful of impersonators.

Only trust links published from official Powerloom channels:

• Blog: https://powerloom.io/blog
• X: https://x.com/powerloom
• Docs: https://docs.powerloom.io
• Discord: https://discord.gg/powerloom
• Telegram: https://t.me/PowerloomProtocol
• GitHub: https://github.com/powerloom

Thank you

Powerloom only existed because people chose to build, run nodes, test, give feedback, and believe that web3 data infrastructure could be better.

To the snapshotters, validators, developers, partners, investors, contributors, and community members who supported us: thank you.

We are sorry we could not take Powerloom further. We will focus now on making the wind-down clear, safe, and respectful.

— Anomit and Swaroop

That distinction matters when you are building agents, running risk models, or pricing anything on-chain. The last swap on a quiet pool might be six blocks old. The last swap on WETH might show zero movement while the alt pair you actually trade is drifting 2%. If your price gate depends on swap events, you are blind between trades.

Our feed closes that gap. Every ~12 seconds on ETH mainnet, every indexed pool gets a USD price derived from on-chain state (slot0), anchored through a consistent conversion graph: USDC, USDT, and DAI pinned at $1, ETH priced from the canonical USDC/WETH pool, and every other token routed through the deepest WETH or USDC reference pool. No interpolation, no stale oracle heartbeat, no centralized indexer.

Today the feed is live in production on BDS mainnet, the premium metering is active with weighted credit deductions, and the API is ready to consume.

Consume It Now

You need a BDS API key. Get one at bds-metering.powerloom.io/metering — email signup, no wallet, 2 free credits on the house.

The consumption pattern for any token is: find pools, then get prices per pool (not tokenPrices/all unless you know the token has at most ~20 pools). Here is a real example with Asteroid Shiba (ASTEROID, 0xf280B16EF293D8e534e370794ef26bF312694126).

Step 1: Find which pools list this token:

curl -s -H "Authorization: Bearer sk_live_... \
  "https://bds.powerloom.io/api/mpp/token/0xf280B16EF293D8e534e370794ef26bF312694126/pools" | jq '.pools | keys'

Returns six pools:

[
  "0x08989C58bC6b18e8e2910815309A89DE4F1275B2",
  "0x0e55Db2d5e07cc6B067f352bA35A6beaFB33c282",
  "0x168E9B3c9ddFB013A4130276F9c500A3CE50FdE7",
  "0x53e3d506F468c4BC30cc8CaA21Eb7E56c2fA2D55",
  "0x76718094c323e3F0d99A0521DFc66523d1e96083",
  "0xC41BB16Bb5F7121947E381BB2b20E2a723f39163"
]

Two are against USDC, two against WETH, two against USDT. Each pool entry includes full token metadata (symbol, decimals, fee tier).

Step 2: Get USD price in a specific pool:

curl -s -H "Authorization: Bearer sk_live_... \
  "https://bds.powerloom.io/api/mpp/token/price/0xf280B16EF293D8e534e370794ef26bF312694126/0x08989C58bC6b18e8e2910815309A89DE4F1275B2"

Returns a scalar USD price:

0.000162681

That is ASTEROID's USD price in the USDC pool at the latest finalized epoch. One HTTP call, one number.

Step 3: Get price at a specific block:

curl -s -H "Authorization: Bearer sk_live_... \
  "https://bds.powerloom.io/api/mpp/token/price/0xf280B16EF293D8e534e370794ef26bF312694126/0x08989C58bC6b18e8e2910815309A89DE4F1275B2/25215944"

Same scalar, but pinned to block 25215944. This is what Pulse uses for price gates: a verifiable, epoch-specific USD number.

Price history over time: the time series endpoint:

curl -s -H "Authorization: Bearer sk_live_... \
  "https://bds.powerloom.io/api/mpp/timeSeries/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2/0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640/3600/144"

This returns WETH price history from the USDC/WETH pool: 1-hour intervals (3600s), 144 steps. Real response:

{
  "priceSeries": [
    {"blockNumber": 25215644, "price": 2023.30, "timestamp": 1780234031},
    {"blockNumber": 25215656, "price": 2023.25, "timestamp": 1780234175},
    {"blockNumber": 25215668, "price": 2023.22, "timestamp": 1780234319},
    ...
    {"blockNumber": 25215944, "price": 2008.67, "timestamp": 1780237643}
  ]
}

Each entry has a block number, the USD price, and a Unix timestamp. This is the endpoint you reach for when building charts, computing moving averages, or backtesting strategies against historical prices.

Two-Line Agent Prompts

You do not need bds-agent to consume the feed. Here are prompts for any agent framework that can call HTTP APIs.

Hermes (cron job, periodic price report to Telegram):

Fetch the AAVE price in the WETH pool:
GET https://bds.powerloom.io/api/mpp/token/price/0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9/0x1353fE67fFf8f376762b7034DC9066f0bE15a723
with Authorization: Bearer sk_live_... Reply: "AAVE @ $<price>" and send to Telegram.

OpenClaw (one-shot, multi-pool price monitoring):

Use the powerloom-bds-univ3 skill. First call bds_mpp_token_pools for 0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9 to find pools. Then call bds_mpp_token_price_token_address_pool_address for each WETH pool. Report all USD prices.

Both hit the same weighted metering path. Both get DSV-finalized data. The agent framework is your choice; the data product is the same.

Premium Metering Is Live

The /mpp/ routes on the resolver node now apply weighted credit deductions. Premium endpoints like token/price (weight 5) and token/price/{block} (weight 10) cost more than standard snapshot reads (weight 1) because every price is a batched slot0 read through an anchored USD graph backed by DSV-finalized snapshots, not a cached last-trade lookup. Time series carries a base weight of 5 with a lookback multiplier that scales with how far back you query (4x at 1 hour, 128x at 24 hours, up to 2048x for >7 days).

For the full credit weight table and lookback multiplier breakdown, see Credit Weights in the Endpoint Catalog.

Do not use tokenPrices/all for USDC, WETH, or other hub tokens. Those tokens have thousands of indexed pools; the API only supports ≤20 pools per tokenPrices/all request and will error on majors. The supported pattern is always: GET /mpp/token/{token}/pools, then GET /mpp/token/price/{token}/{pool} (or .../{block}) for each pool you need — the same flow Pulse and Guard use on pinned pools.

Your balance and per-endpoint usage are visible at bds-metering.powerloom.io/metering/account. Paste your API key and you see the USAGE tab: balance, daily spend, top endpoints, recent activity.

How It Works

The pipeline reads on-chain pool state for every indexed Uniswap V3 pool, at every block, and converts every price to USD through a consistent anchor graph. USDC, USDT, and DAI are pinned at $1. ETH gets its USD price from the canonical USDC/WETH pool. Every other token routes through the deepest WETH or USDC reference pool available. Zero-trade blocks still get prices. No interpolation, no post-hoc inference.

The entire pipeline runs inside the Powerloom snapshotter, gets validated by the DSV network, and lands as a finalized snapshot with on-chain CID. Compute is open source at github.com/powerloom/snapshotter-computes.

Sneak Peek — Pulse

Pulse trades on this feed. It's a confluence-based auto-trader built into bds-agent that enters when price drift, volume burst, and directional flow align on the same pool. Full post coming next. Here's a live session from today:

▶ bds-agent trade run --profile bds-tgtest2 \
    --multi-pool --verbose --size 5 --price-source usd \
    --exit-take-profit-pct 0.25 --daily-loss-limit 5

trade mode=multi-pool watching=14 (USDC/WETH, USDC/SEI, uPEG/USDC,
  WBTC/USDC, USDC/ASTEROID, USDC/USDT, USDC/AEVO +6) size=$5.00 max_open=2

13:23:02  USDC/WETH  px=+0.00%  burst=0.00x  imb=0%  → warming up
13:24:32  USDC/WETH  px=+0.01%  burst=12.00x imb=95% → gates not met: price
13:25:20  AI/USDC    px=-0.29%  burst=12.00x imb=2%  → gates not met: imb
13:27:12  AI/USDC    px=-0.36%  burst=12.00x imb=1%  → gates not met: imb

  ... scanning continues across 14 pools ...

  ▶ OPEN LONG: USDC/ASTEROID  entry=0.000154927  size=$5.00
  ▶ OPEN LONG: USDC/SEI       entry=0.066940     size=$5.00

Position status as trades close:

▶ bds-agent trade status
  Position LONG×2  open=2
    [1] USDC/ASTEROID  entry=0.000154927  size=$5.0
    [2] USDC/SEI       entry=0.066940     size=$5.0
  daily P/L: $0.03

  ... SEI position closed (take-profit) ...

  Position LONG  open=1
    [1] USDC/ASTEROID  entry=0.000154927  size=$5.0
  daily P/L: $0.04

  ... ASTEROID position closed ...

  Position FLAT
  daily P/L: $0.04
  usdc_balance: 12.431457

Both LONGs closed in profit. +$0.04 across two $5 positions. WETH/USDC had 12× burst volume but the price was flat at +0.01%, so Pulse skipped it every time. ASTEROID and SEI had all three: price moving, volume spiking, flow tilting. That only shows up when you price every block, not just when swaps fire.

How This Is Different

What's Next

This post covers the price feed itself. Pulse and Threshold Guard each get their own deep-dive posts next: how the confluence gates work, position management, exit strategies, and live trade walkthroughs. The feed is the product; Pulse and Guard prove why it matters.

Get your free API key, hit the endpoint, and see what block-accurate prices look like.

Resources

• API key + usage dashboard: bds-metering.powerloom.io/metering/account
• Docs: docs.powerloom.io/agents-and-bds/
• Metering & API Keys: docs.powerloom.io/agents-and-bds/metering-and-api-keys
• Hosted MCP: bds-mcp.powerloom.io/sse
• Headless CLI: pypi.org/project/bds-agent
• Compute module source: github.com/powerloom/snapshotter-computes
• Previous post: Aeon Whale Radar — Verified DeFi Alerts, Zero Infrastructure

Spread the word. Discord | X | Telegram | GitHub

Today we are shipping the third path: Aeon.

Aeon is an open-source agent scheduler that runs entirely inside GitHub Actions. Github: powerloom/aeon-skills brings Whale Radar into that runtime. Same per-block snapshot catch-up, same deterministic cursor, same provable alerts. No VPS, no cron server, no MCP server to maintain.

If you want verified DEX alerts flowing to Telegram or Discord without running any infrastructure, this is the shortest path.

The first production run caught 27 whale alerts in a single session:

🐳 Whale alert: WBTC → USDC  $245,000
Pool: 0x99ac8cA7087fA4A2A1FB6357269965A2014ABc17
Epoch: 25185640
✅ Verified on-chain
   cid: bafkrei...
   protocolState: 0x1d0e010Ff11b781CA1dE34BD25a0037203e25E2a
   dataMarket: 0x26c44e5CcEB7Fe69Cffc933838CF40286b2dc01a

Every alert includes the DSV verification block: CID, epoch, protocolState, dataMarket. Checkable on-chain via cast call against ProtocolState.maxSnapshotsCid, or via the MCP verify_data_provenance tool.

How it works

The Aeon skill uses a deterministic prefetch pattern that keeps the LLM out of the data pipeline:

1. A Python prefetch script runs outside the LLM sandbox (prefetch-bds.sh). It reads the epoch cursor from memory/powerloom-bds-state.json, loops from lastStreamEpoch + 1 through the latest finalized block (cap 10 per run), fetches snapshots from GET /mpp/snapshot/allTrades/{block}, builds alert payloads, and writes them to .bds-cache/alerts.json.

2. The LLM reads the pre-built alerts from cache and dispatches them via ./notify to Telegram, Discord, or Slack. It never fetches data, never manages a cursor, never touches the BDS API.

3. The epoch cursor is auto-committed by the GitHub Actions workflow, so the next run picks up exactly where the previous one left off.

This is the same separation we described in the Whale Radar deep-dive: the data layer owns correctness, the agent layer owns delivery. Aeon just runs it on GitHub's infrastructure instead of yours.

GitHub Actions cron (every ~15 min)
  │
  ├─ prefetch-bds.sh (Python, outside sandbox)
  │    • Read cursor from memory/powerloom-bds-state.json
  │    • GET /mpp/snapshot/allTrades/{block} (Bearer sk_live_...)
  │    • Resolve pool metadata, filter by USD threshold
  │    • Write alerts to .bds-cache/alerts.json
  │    • Write new cursor back to state file
  │
  └─ LLM sandbox (Aeon skill)
       • Read .bds-cache/alerts.json
       • Dispatch via ./notify (Telegram / Discord / Slack)

Setup

Full walkthrough with screenshots: docs.powerloom.io/agents-and-bds/aeon-whale-radar

The short version:

1️⃣ Fork Aeon and enable Actions in your fork

2️⃣ Clone aeon-skills and run install-into-aeon.sh against your fork

3️⃣ Add powerloom-bds: { enabled: true, schedule: "*/5 * * * *" } to aeon.yml

4️⃣ Set GitHub secrets: BDS_API_KEY (required), TELEGRAM_BOT_TOKEN + TELEGRAM_CHAT_ID (for TG alerts), or DISCORD_WEBHOOK_URL (for Discord)

5️⃣ Commit, push, check the Actions tab

Metering — API Key, Credits, and Usage Dashboard

Every path into BDS starts with an API key. Get one at bds-metering.powerloom.io/metering — email signup, no wallet required. 2 free credits on signup. 1 credit = 7,200 epochs = 1 full day of continuous polling on ETH mainnet.

When free credits run out, top up with POWER on Powerloom mainnet or USDC on Ethereum, Polygon, Arbitrum, or Optimism. See the Metering & API Keys docs for live plans and payment instructions.

Usage dashboard — the metering frontend got a full overhaul. The new USAGE tab shows:

• Current credit balance and rate limits
• Usage broken down by day (last 30 days)
• Top API endpoints hit
• Recent activity log

Paste your API key at bds-metering.powerloom.io/metering and you get full visibility into spend without writing any code. Previously you had to hit GET /credits/balance via curl or bds-agent credits balance. Now the dashboard does it for you.

📖 Metering & API Keys docs

Three paths, same pipeline

All three consume the same BDS snapshots from the same DSV-validated data market. All three produce alerts with the same verification block. The choice is about where you want to run, not what you get.

Docs for all three paths:

• Aeon Whale Radar
• OpenClaw & Hosted MCP
• Headless CLI

Resources

• Aeon skill: github.com/powerloom/aeon-skills
• Aeon setup: docs.powerloom.io/agents-and-bds/aeon-whale-radar
• OpenClaw skill: clawhub.ai/powerloom-bot/powerloom-bds-univ3
• Headless CLI: pypi.org/project/bds-agent
• Metering: bds-metering.powerloom.io
• Docs: BDS and Agents: Quickstart
• Previous post: Whale Radar Recipe — Under the Hood

Spread the word. Discord | X | Telegram | GitHub

🐳 Whale alert: WBTC → USDC  $245,000

Pool: 0x99ac8cA7087fA4A2A1FB6357269965A2014ABc17
Epoch: 24785719
✅ Verified on-chain
   cid: bafkrei...
   protocolState: 0xa1100CB00Acd3cA83a7C8F4DAA42701D1Eaf4A6c
   dataMarket: 0x4198Bf81B55EE4Af6f9Ddc176F8021960813f641

That alert came from Whale Radar, a ready-to-run recipe in the powerloom-bds-univ3 skill. It watches Uniswap V3 trades, filters for large swaps, resolves pool metadata, deduplicates alerts, and ships each notification with DSV-backed provenance.

If you need verified DEX alerts, whale monitoring, pool-volume triggers, or agent-readable DeFi data without running your own indexer, this recipe is the shortest path from BDS data to production notifications.

This post explains how Whale Radar works, what each alert includes, and how to run it yourself.

Every Whale Radar Alert Includes

• Trade direction and estimated USD value
• Pool address with resolved token metadata (symbols, decimals)
• Epoch and transaction/block context
• DSV verification block: CID, epoch ID, protocolState, dataMarket

Before You Start

You need a free BDS API key. Two ways to get one:

1. Browser signup (no install): Go to bds-metering.powerloom.io/metering — enter email + agent name, complete Turnstile, copy your sk_live_... key. 30 seconds, no wallet, no CLI.

2. CLI signup: Run bds-agent signup (requires pip install bds-agent first). Same browser verification flow, key saved to ~/.config/bds-agent/profiles/.

Both give you 2 free credits (1 credit = 7,200 epochs = 1 full day of continuous polling on ETH mainnet).

Full quickstart docs: docs.powerloom.io/agents-and-bds/quickstart

Our previous post walks through the browser signup flow with screenshots: Powerloom's Agentic Consumption Layer Is Now Open

Terms

In OpenClaw terms, a skill is an installable package of tools and scripts. A recipe is a ready-to-run workflow inside that skill. Whale Radar is a recipe inside the powerloom-bds-univ3 skill.

Run It Now: One-Shot Prompt in OpenClaw

Got your sk_live_... key from browser signup? Open OpenClaw and paste the one-shot prompt:

Copy the full prompt from GitHub

This is a complete, copy-paste prompt that tells the agent exactly what to do. It will:

1. Install powerloom-bds-univ3 from ClawHub and run npm install
2. Ask for your sk_live_... API key (gathered in chat before proceeding)
3. Ask if you want Telegram alerts — if yes, it collects your bot token and chat ID; if no, alerts go to stdout
4. Set POWERLOOM_API_KEY in the skill environment
5. Run a pre-flight credit check via node scripts/ensure-credits.mjs
6. Create a 15-second cron running node scripts/whale-cron.mjs with all required env vars

Whale alerts start flowing within seconds. Every alert includes the on-chain verification block.

When your 2 free credits run out, top up with POWER on Powerloom mainnet (chain 7869) or USDC on Ethereum or Polygon. See the wallet-funded variant for autonomous on-chain pay-signup.

Data Flow

BDS API (bds.powerloom.io)
  /mpp/snapshot/allTrades?from_epoch=N&max_events=100
           │
           ▼
Hosted MCP Server (bds-mcp.powerloom.io/sse)
  Tool: bds_mpp_snapshot_allTrades
  Auth: Bearer sk_live_...
           │
           ▼
OpenClaw cron (every 15s)
  node scripts/whale-cron.mjs
    • Epoch cursor from state file
    • Dedupe via fingerprints
    • Resolve pool metadata
    • Format and dispatch
           │
           ▼
Output
  Telegram / Discord / stdout

The Hosted MCP Server

Catalog tools map one-to-one with /mpp/... routes. Two fixed tools handle cross-cutting concerns:

Zero balance returns 402 before any tool executes.

The API: /mpp/snapshot/allTrades

The cron calls one MCP tool:

const result = await callTool("bds_mpp_snapshot_allTrades", {
  from_epoch: lastEpoch,
  max_events: 100
});

Equivalent curl:

curl -H "Authorization: Bearer sk_live_..." \
  "https://bds.powerloom.io/api/mpp/snapshot/allTrades?from_epoch=25121752&max_events=100"

Parameters: from_epoch (exclusive, omit for latest), max_events (default 50, max 100).

Response:

{
  "epoch": { "begin": 25121752, "end": 25121760 },
  "data": {
    "trades": [
      {
        "poolAddress": "0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640",
        "data": {
          "sender": "0x...",
          "calculated_token0_amount": -421.5,
          "calculated_token1_amount": 1312000.0,
          "token0_price": 3112.45
        },
        "log": { "transactionHash": "0xa1b2...", "blockNumber": 25121755 }
      }
    ]
  },
  "verification": {
    "cid": "bafkrei...",
    "epochId": 25121760,
    "projectId": "allTradesSnapshot:0x4198Bf81B55EE4Af6f9Ddc176F8021960813f641:mainnet-BDS_MAINNET_UNISWAPV3-ETH",
    "protocolState": "0xa1100CB00Acd3cA83a7C8F4DAA42701D1Eaf4A6c",
    "dataMarket": "0x4198Bf81B55EE4Af6f9Ddc176F8021960813f641"
  }
}

The verification block comes from DSV consensus.

How USD Value is Computed

Whale Radar estimates USD value from the trade amounts and token price fields in the snapshot payload:

• calculated_token0_amount and calculated_token1_amount give the swap volumes
• token0_price gives the reference price at snapshot time

For display, the recipe resolves token symbols and decimals through the pool metadata tool and caches the result locally in .powerloom/pool-metadata-cache.json.

Epoch Cursor

The skill tracks lastStreamEpoch in .powerloom/whale-cron-state.json:

// lib/state.mjs
export function loadState(file) {
  if (!existsSync(file)) {
    return { lastStreamEpoch: null, emittedFingerprints: [] };
  }
  return JSON.parse(readFileSync(file, "utf8"));
}

Each cron tick fetches from_epoch = lastStreamEpoch + 1 (since from_epoch is exclusive), processes new trades, then writes back epoch.end as the new cursor. If OpenClaw restarts, the next run resumes exactly where it left off.

State lives outside the skill directory (WHALE_CRON_STATE_FILE=$OPENCLAW_WORKSPACE_DIR/.powerloom/...) so it survives reinstall.

Deduplication

Trades can appear at epoch boundaries. The script fingerprints each one:

export function fingerprintTrade(t) {
  const tx = t.log?.transactionHash || t.transactionHash || "";
  const bn = t.log?.blockNumber ?? t.blockNumber ?? "";
  return `${tx}:${bn}`;
}

Stored in emittedFingerprints[] with LRU-500 bound. Previously emitted trades are skipped.

Verification

Every alert includes the verification block:

✅ Verified on-chain
   cid: bafkrei...
   epoch: 25121760
   protocolState: 0xa1100CB00Acd3cA83a7C8F4DAA42701D1Eaf4A6c
   dataMarket: 0x4198Bf81B55EE4Af6f9Ddc176F8021960813f641

Verify independently via cast call on the Powerloom anchor chain:

cast call 0xa1100CB00Acd3cA83a7C8F4DAA42701D1Eaf4A6c \
  "maxSnapshotsCid(address,string,uint256)(string,uint8)" \
  0x4198Bf81B55EE4Af6f9Ddc176F8021960813f641 \
  "allTradesSnapshot:0x4198Bf81B55EE4Af6f9Ddc176F8021960813f641:mainnet-BDS_MAINNET_UNISWAPV3-ETH" \
  25121760 \
  --rpc-url https://rpc-v2.powerloom.network

Or via MCP tool verify_data_provenance with the same fields.

Alternative: bds-agent CLI (Headless, One Extra Install Step)

The OpenClaw path above gets you running with zero installs. If you prefer a terminal-first workflow, the bds-agent CLI gives you the same capabilities but requires pip install bds-agent (or uv tool install bds-agent) first.

pip install bds-agent
# or
uv tool install bds-agent

After installing, sign up for a free key:

bds-agent signup

Browser verification, key saved to ~/.config/bds-agent/profiles/<profile>.json.

Pre-packaged recipe

The CLI ships example recipes in examples/. For DEX trade alerts:

bds-agent config init
bds-agent run examples/dex-alerts.yaml

This uses the same /mpp/stream/allTrades endpoint via a streaming source with min_usd and volume_spike rules. See examples/dex-alerts.yaml and examples/dex-alerts-slack.yaml in the bds-agent-py repo for the full YAML.

Natural language query

bds-agent llm setup anthropic
bds-agent query "trade volume of pool 0xc7bBeC68d12a0d1830360F8Ec58fA599bA1b0e9b in last hour" --execute

MCP stdio

For IDEs that spawn child processes:

bds-agent mcp

Stdio transport for Cursor, Claude Desktop, Claude Code. The hosted server at bds-mcp.powerloom.io/sse uses HTTP SSE instead.

Credits

1 credit = 7200 epochs.

How consumption works

Every /mpp/... request deducts credits. The MCP server forwards your Bearer token to the resolver, which applies the deduction. Zero balance returns 402.

At a 15-second polling interval, the free 2-credit signup is intended for experimentation. For long-running production monitoring, top up with a paid plan.

Check balance:

curl -H "Authorization: Bearer sk_live_..." \
  https://bds-metering.powerloom.io/credits/balance

# or
bds-agent credits balance

Plans

Live from GET /credits/plans:

List current plans:

curl -sS https://bds-metering.powerloom.io/credits/plans | jq
bds-agent credits plans

Pay-signup

bds-agent credits setup-evm
bds-agent signup-pay --plan-id launch_10_pl_power_cgt --chain-id 7869 --token-symbol POWER

Top-up

bds-agent credits topup

What's Next

More data markets are coming. The same skill patterns work across chains and protocols. When a new market goes live, you add the endpoint to your catalog, point your MCP client at the new endpoint, and your existing recipes just work.

Token-Flow gets its own deep-dive next. Then Pulse. Then DeFi Analyst.

Try the free key, run Whale Radar, and bring your first verified DeFi alert into Telegram or Discord.

Resources

• ClawHub: powerloom-bds-univ3
• Free-key prompt: 09-openclaw-one-shot-free-key.md
• Wallet-funded prompt: 08-openclaw-one-shot.md
• CLI: bds-agent-py
• MCP: bds-mcp-server
• Docs: Metering · OpenClaw & MCP · Headless CLI
• Community: Telegram · Discord · X

Here's what it looks like on the consumption side — a Telegram alert that arrived minutes after setup:

🐳 Whale alert: WBTC → USDC  $245,000

Pool: 0x99ac8cA7087fA4A2A1FB6357269965A2014ABc17
Epoch: 24785719
✅ Verified on-chain
   cid: bafkrei...
   project: allTradesSnapshot:0x26c4...

Every alert carries a CID that maps back to DSV-finalized state on the Powerloom anchor chain. Snapshotters computed the data, validators finalized it, the agent surfaced it — provenance preserved end-to-end.

Why this matters

Agents need reliable data. Most data APIs are "trust the vendor" — you take what you're given and hope it's right. BDS is the opposite: every response includes a verification object the agent (or you) can check against the on-chain commitment. The same cid/epochId/projectId that ships in the API payload also lives in ProtocolState.maxSnapshotsCid on Powerloom mainnet. If the CID matches, the data was finalized by DSV consensus before it reached you. That is the difference between a normal API response and a verifiable BDS response.

A decentralized validator mesh, finalized data, and now an agentic consumption layer on top — that's what we're opening up today.

Get a free API key (2 credits, no wallet)

Two ways to get your free key — pick whichever fits:

Option 1 — Browser UI (no CLI required): go to BDS metering service signup page, enter your email and agent name, and click Continue.

Complete the Cloudflare Turnstile challenge on the verification page, accept the Terms of Service, and click Verify.

Your API key appears immediately. Copy it — it's shown only once in this flow.

Option 2 — CLI: bds-agent signup runs the same device flow from your terminal. See the full CLI signup walkthrough.

The sk_live_... key is universal — it works against the metered HTTP endpoints, the OpenClaw skill, the hosted MCP server, and any framework that speaks Bearer auth. Top up later with native $POWER (50 $POWER → 10 credits + 2 bonus = 12 total) or any supported plan token; the same key is preserved.

The sk_live_... key is universal — it works against the metered HTTP endpoints, the OpenClaw skill, the hosted MCP server, and any framework that speaks Bearer auth. Top up later with native $POWER (50 $POWER → 10 credits + 2 bonus = 12 total) or any supported plan token; the same key is preserved. (Browser signup details)

Pick your path

Same key. Same /mpp routes. Same balance. Same verification objects. Pick whichever fits your workflow — or use both.

Path A — 🦞 OpenClaw one-shot (free key)

The powerloom-bds-univ3 skill on ClawHub is where OpenClaw meets BDS. With the free sk_live_... from above, the entire setup is a single prompt — no wallet, no on-chain payment.

Paste the free-key one-shot prompt into OpenClaw. The agent's first response is a question:

Got it. Let me gather the required inputs first.

(a) API key: paste your sk_live_... from `bds-agent signup`.
(b) Telegram alerts: Do you want Telegram alerts for whale swaps?
    If yes, paste POWERLOOM_TELEGRAM_BOT_TOKEN and POWERLOOM_TELEGRAM_CHAT_ID.
    If no, type 'skip' and alerts will print to stdout only.

You paste the key, then either both Telegram values or skip. From there the agent installs the skill from ClawHub, wires the env into OpenClaw config, and creates a Whale Radar cron firing every 15 seconds via whale-cron.mjs. No wallet credentials. No private key. No on-chain payment.

The flagship output is the Telegram alert from the top of this post. Every alert carries the full verification block — cid, epochId, projectId — that anyone receiving the alert can verify on-chain.

The skill ships:

• Whale Radar (whale-cron.mjs) — bounded bds_mpp_snapshot_allTrades, USD-threshold alerts, default cron at 15s
• Token-Flow — multi-pool, token-keyed monitoring across all indexed pools for a given token
• Autonomous DeFi Analyst — LLM-generated market analysis with random verify_data_provenance probes embedded in operation
• Telegram + Discord sinks — both surface the verification block in every alert

Want more credits? Upgrade to a paid plan

The 2 free credits cover roughly 1440 epochs of metered data. When you want a bigger plan, two upgrade paths:

1. Top up the same key — bds-agent credits topup against your existing sk_live_.... Same key, more credits.
2. Run the wallet-funded one-shot — paste the 08-openclaw-one-shot.md prompt instead. Same input-gathering pattern (API key + Telegram dispatch in chat upfront), but the agent then runs scripts/signup-pay.mjs to broadcast a native $POWER transfer on chain 7869 and claim a fresh sk_live_... for the launch_10_pl_power_cgt plan (50 $POWER → 10 credits + 2 bonus = 12 total). Use a burner wallet only for the private key.

The hosted MCP server at https://bds-mcp.powerloom.io/sse works beyond OpenClaw too — Claude Code, Cursor, LangGraph, CrewAI, anything that supports SSE MCP transport with a Bearer header.

(OpenClaw & Hosted MCP docs | Quickstart Path A | Free-key prompt | Wallet-funded prompt)

Path B — 🐍 bds-agent CLI (Headless, Programmatic)

For headless orchestration, CI pipelines, custom YAML recipes, or any environment where you want the agent driving its own queries directly against the metered HTTP endpoints. The CLI is uv-installable and works on the same sk_live_... from the free signup above.

git clone https://github.com/powerloom/bds-agent-py.git
cd bds-agent-py && uv sync && uv tool install .
bds-agent config init

config init writes BDS defaults — resolver base URL, endpoint catalog, Powerloom chain RPC, ProtocolState and DataMarket contract addresses — to your profile.

Query in plain language (LLM-backed; works with Anthropic, OpenAI, Ollama, local GGUF, or Apple Intelligence):

bds-agent llm setup anthropic && bds-agent llm use anthropic
bds-agent query "Top 5 Uniswap V3 swaps by USD volume in the last hour" --execute

Generate a YAML recipe from a description:

bds-agent create "Alert when any single swap exceeds $100k"

Run a recipe (no LLM needed for run):

bds-agent run examples/dex-alerts.yaml --profile default

The repo ships pre-packaged recipes including examples/dex-alerts.yaml, which streams indexed DEX swaps and triggers on min_usd (default $50k) and volume_spike (3× rolling average over 10 epochs). Set verify: true in any recipe to enable on-chain CID verification per batch — the runner calls ProtocolState.maxSnapshotsCid and routes a rule: verification alert on mismatch.

More credits when you need them: bds-agent signup-pay --plan-id launch_10_pl_power_cgt --chain-id 7869 --token-symbol POWER runs the same autonomous on-chain payment flow (50 $POWER → 12 credits) against your funded wallet, and the new key replaces the free one in your profile. See the Pay-signup reference.

(Full operator guide | Quickstart Path B | GitHub)

Verification: trust, but verify

Every BDS response from a supported route includes a verification object:

{
  "epoch": 24785718,
  "snapshot": { "...trade data..." },
  "verification": {
    "cid": "bafkreib6h6au6hyv3hnx3wmbysu4lcoouah2yicst3nwnwndpcw2yxxrta",
    "epochId": 24785718,
    "projectId": "allTradesSnapshot:0x26c44e5CcEB7Fe69Cffc933838CF40286b2dc01a:mainnet-BDS_MAINNET_UNISWAPV3-ETH"
  }
}

Anyone can verify independently:

cast call 0x1d0e010Ff11b781CA1dE34BD25a0037203e25E2a \
  "maxSnapshotsCid(address,string,uint256)(string,uint8)" \
  0x26c44e5CcEB7Fe69Cffc933838CF40286b2dc01a \
  "allTradesSnapshot:0x26c44e5CcEB7Fe69Cffc933838CF40286b2dc01a:mainnet-BDS_MAINNET_UNISWAPV3-ETH" \
  24785718 \
  --rpc-url https://rpc-v2.powerloom.network

If the CID matches, the response was finalized by DSV consensus before it reached the agent. That's the contract every alert carries. Both bds-agent run --verify and the OpenClaw verify_data_provenance MCP tool wrap this same call. Alerts emitted by either path include the full verification block so downstream consumers can run the same check. (Verification in Agent Workflows)

The SKILL.md pattern

Both bds-agent-py and the OpenClaw skill publish a SKILL.md at their repository root:

curl -sL https://raw.githubusercontent.com/powerloom/bds-agent-py/main/SKILL.md
curl -sL https://raw.githubusercontent.com/powerloom/powerloom-bds-univ3/main/SKILL.md

A single flat markdown file with the full command surface, metering HTTP flow, environment variables, common mistakes, and canonical links. Any LLM-driven agent or orchestrator can fetch it at session start and bootstrap itself without parsing full documentation.

This is the agent-native interface pattern we want more data services to adopt: framework-neutral orchestration directives in one file any agent can ingest. If you're building a data API and you want autonomous agents to use it, publish a SKILL.md. (SKILL.md details →)

Get started

• Full Docs: Agents & BDS | ClawHub skill | GitHub: bds-agent-py | GitHub: powerloom-bds-univ3
• Metering & API Keys | Headless CLI Guide | Verification

What's next

• More recipes — price, volume, and flow-imbalance regime change alerts
• More data markets — Aave V3 next, same bds-agent and ClawHub patterns
• More integrations — OpenClaw was the first, not the last. Hermes, LangGraph, CrewAI, Claude Code, and Cursor are all in scope.

Walkthrough videos for both paths are dropping shortly.

Spread the word: Discord | X | Telegram | GitHub | Website

Powerloom’s Decentralized Sequencer-Validator network is now live on mainnet for the Blockchain Data Services datamarket. BDS is serving verified Uniswap V3 data in production, supported by 3,000+ daily active Snapshotter Lite slots, six stable validator nodes, and more than 500,000 finalized snapshot batches committed on-chain.

This marks a major shift for Powerloom: decentralization is no longer just a protocol goal. It is how the network is operating today. With BDS live, $POWER is now connected to a working datamarket economy spanning snapshotters, validators, verifiable data demand, and the next phase of agent-first consumption.

We have spent the last few years building toward a simple but ambitious goal: useful datamarkets that do not depend on a single company, a single backend, or a single privileged sequencer.

• 3000+ daily active Snapshotter Lite slots
• 6 stable, long-running Validator nodes
• over 500k+ finalized snapshot batches committed onchain with 99% completion rate
• Foundation operated Resolver node serving structured Uniswap V3 data on top of the datamarket, with cryptographic provenance
• Agentic datamarket economy, with $POWER as the currency of consumptive utility, powered by the headless CLI as well as OpenClaw integration

Decentralization is no longer only an architectural direction for us; it is how the network is operating.

The preparation and build-up

Staking, validator consensus, agentic demand for accurate, verified data, and protocol-native incentives now reinforce the positive feedback cycles of utility of $POWER within the datamarket economy that we have always envisioned.

In our last couple of blogs, we had shared the larger scope of the protocol's direction with regard to decentralization of sequencing and validation and launch of the agentic, datamarket economy with BDS preview.

Since then, we went live with the DSV Devnet followed by DSV Mainnet Alpha for validators who had expressed their interest in joining the Validator program. This helped us iron out major operational issues.

We ran tests and simulations at mainnet scale for almost two months between the initiatives noted above to fine tune networking parameters, onchain protocol state configurations, fix concurrency and deadlock issues, all the while without compromising on the open, decentralized and permissionless nature of the consensus and aggregation layer.

While we were prepping the DSV mesh with an observed rate of 99%+ finalization among the participating validators in the test networks, we also

• offered the first Ecosystem grant to BazaarX
• released Snapshotter Loyalty Rewards
• onboarded and prepared Snapshotter Lite nodes for the BDS datamarket on DSV Mainnet, well in advance with detailed instructions

And finally on March 3 2026, we went live with the first epoch for the BDS datamarket.

Why this matters for $POWER

BDS gives $POWER a direct role in a working datamarket economy.

Snapshotters produce data ➡ validators finalize it ➡ resolvers serve it ➡consumers access verified outputs. As agent-first consumption expands through OpenClaw, MCP, and bds-agent-py, $POWER becomes tied to data usage, not only network participation.

This is the feedback loop Powerloom has been building toward:

• useful datamarkets create demand for verified outputs;
• verified outputs require decentralized production and validation; and
• protocol-native incentives coordinate the participants who make that possible.

DSV Network: Evolution of the Consensus and Aggregation Layer of Powerloom Protocol

To recap, our protocol journey has gone through three distinct stages.

• Protocol v1: snapshotter nodes could compute useful data and anchor it on-chain. But every snapshot submission required its own on-chain transaction. That made the system expensive, slow, and unsuitable for high-frequency datamarkets.
• Protocol v2 was the performance breakthrough. It introduced a high-throughput sequencer that batched snapshots, uploaded payloads to IPFS, and anchored finalized batch CIDs on-chain through `submitSubmissionBatch()`. That removed the per-snapshot transaction bottleneck and made practical datamarkets possible.

But it still left one hard problem: the sequencer was centralized. Powerloom Foundation had to operate it, maintain it, and make deep configuration changes if the network ever needed to support a new market or modify dynamic operational parameters like load balancing on the p2p listening interface or change reward update batch sizes among other things.

DSV Mainnet is the decentralization of that high-throughput sequencer architecture. Multiple validators now form a peer-to-peer mesh using libp2p and gossipsub. Snapshot submissions propagate across that mesh, are aggregated in two stages, and reach validator consensus before a finalized batch is anchored on-chain.

DSV keeps the performance gains of Protocol v2 while moving the sequencer responsibility out of a monolithic Foundation-operated service and into a validator network. This allows for a free market economy to flourish and introduce the roles of curators and signaler peers who act as high fidelity filters in the creation of and call for participation in useful datamarkets.

First 30 Days of DSV Mainnet Operations

The BDS mainnet market processes one-block epochs on Ethereum mainnet. Every Ethereum block is a new opportunity for snapshotter nodes to compute data, for validators to aggregate it, and for the finalized output to become available to downstream consumers.

Across 217,295 total epochs assigned for batch submission, the validator layer submitted 212,297 batches and completed 210,200 of them — That represents a 97.7% submission rate across assigned epochs and a 99.01% completion rate once a batch was submitted. 26 of 30 days ran at the full steady-state cadence of 7,200 epochs per day. The batch submission pipeline ran with a median end-to-end latency of 89 seconds from priority assignment to on-chain finalization.

Sustained behavior is the signal here: the network has stayed online, processed live demand, and produced verifiable outputs across mainnet operation.

On the snapshotter side, a separate measurement of 1,811 epochs taken April 17–24 shows between 2,970 and 3,047 unique snapshotter lite nodes eligible for rewards each day — a number that grew through the week as the network expanded. Per epoch, the median eligible node count was 305, with between 3 and 6 validators providing independent batch attestations. Every measured epoch had at least 3 validators, the minimum required for consensus finalization.

Validator reliability tells the clearest story. Of the validator nodes that operated during this period, 6 ran for 22 or more consecutive days.

Two — Node IDs 1 and 5 — ran the full 30-day window with 100% uptime and 99.87% and 99.90% completion rates respectively. Across the six stable long-running nodes, the aggregate completion rate was 98.95% over 193,475 total submissions.

The six stable long-running validators showed the following reliability profile:

Three additional transient nodes participated for shorter periods during operator testing and rotation.

The 2.3% of epochs with no batch submission were caused primarily by epoch broadcast failures during mesh stabilization. These were infrastructure and network-density issues rather than failures of the consensus design itself.

Apart from that, once a validator is selected by VPA to submitting a batch for an epoch, it completes 99.01% of the time.

The network's consensus and completion behavior is already operating at production quality. The remaining coverage gaps come from mesh density: more validators with better-connected bootstrap peers means epoch coverage approaches 100%. Near-term infrastructure work is focused exactly there.

All figures are derived from on-chain events on Powerloom mainnet (chain 7869) and are fully reproducible. Contract addresses and methodology: docs.powerloom.io/dsv-mainnet/stability-and-scale.

BDS: The First Datamarket on DSV Mainnet

The first market covers Uniswap V3 on Ethereum mainnet —

• trade snapshots
• pool state
• token volumes
• liquidity distributions,
• and streaming trades.

These are not simply database rows served from a hosted backend. They are outputs of a decentralized data pipeline: computed by snapshotter nodes, finalized through DSV, resolved through the BDS service layer, and exposed to applications, analysts, and agents.

BDS metered API served by resolvers or full nodes offer structured, verifiable data across agents, applications, dashboards, and monitoring systems. Every response includes a verification object:

{
  "verification": {
    "cid": "bafybeif...",
    "epochId": 24785718,
    "projectId": "allTradesSnapshot:0x26c44e5CcEB7Fe69Cffc933838CF40286b2dc01a:mainnet-BDS_MAINNET_UNISWAPV3-ETH"
  }
}

Any consumer can independently verify the returned CID against the ProtocolState contract on the Powerloom anchor chain:

cast call \
  0x1d0e010Ff11b781CA1dE34BD25a0037203e25E2a \
  "maxSnapshotsCid(address,string,uint256)(string,uint8)" \
  0x26c44e5CcEB7Fe69Cffc933838CF40286b2dc01a \
  "allTradesSnapshot:0x26c44e5CcEB7Fe69Cffc933838CF40286b2dc01a:mainnet-BDS_MAINNET_UNISWAPV3-ETH" \
  24785718 \
  --rpc-url https://rpc-v2.powerloom.network

If the CID matches, the data was finalized by DSV consensus. Consumers do not have to trust the server alone; they can verify the provenance of the data against the protocol.

The full endpoint catalog, verification patterns, and the snapshotter full-node architecture are documented at Powerloom docs.

The following series of releases will expand the consumptive side of the datamarket agentic economy: agent-first consumption through OpenClaw, MCP, and bds-agent-py. That is where BDS stops being only an API and becomes a programmable data layer where autonomous agents can discover, configure, pay for, and verify data.

What's Next For Consumers

In our next post, we'll cover what's already built on top of all of this today:

• Agent-first access to BDS data through OpenClaw
• Headless agent CLI bds-agent-py and framework-neutral agent onboarding
• MCP support

What's Next for the DSV Network

• Mesh strengthening
• Signaller and curator peers
• Data market tiering

Documentation

The full architecture, protocol workflow, on-chain contracts, and operational signals are now documented:

• DSV Mainnet — architecture, roles, protocol workflow, verification, incentives, stability
• BDS Datamarket — what BDS is, the snapshotter resolver, endpoint catalog, verification pattern
• Agents & BDS — agent consumption paths (coming in the next post)

Near-term work for DSV network

Mesh strengthening. The 2.3% epoch miss rate is primarily a bootstrap and coverage problem. Increasing validator mesh density and improving bootstrap peer infrastructure should reduce the impact of node restarts and brief disconnects.

Signaler and curator peers. Signallers and curators are the next step toward permissionless data market creation. Signallers stake $POWER to vote on data market prioritization, while curators assess the quality and relevance of proposed markets. With DSV and BDS proving that the execution layer works, these roles can move more of the network’s market-selection process away from the Foundation and toward protocol participants.

Datamarket tiering. Not all data is the same, and not all consumers need the same thing. The architecture ahead accommodates two distinct modes:

• High-frequency, fast datamarkets — optimized for latency, suited for close-to-the-edge trading applications. These markets prioritize speed and accept a narrower validator set for faster finalization. Think sub-minute snapshots of DEX trade flows or mempool-adjacent data.

• Medium-to-slow, consensus-first datamarkets — optimized for verifiability and redundancy. These markets run more validators, require broader snapshotter consensus before finalization, and accept slightly higher latency in exchange for provably accurate data. Suited for risk systems, compliance use cases, and anything where accuracy matters more than milliseconds.

In Conclusion

DSV proves that Powerloom’s high-throughput data market architecture can operate without a single privileged sequencer.

BDS proves that the architecture can serve real, verifiable data in production.

The next step is to make this economy increasingly self-directed: more validators, stronger mesh coverage, signaller and curator peers, tiered data markets, and agent-first consumption paths that allow autonomous systems to discover, pay for, and verify data directly.

That is the direction Powerloom has been building toward from the beginning: useful, verifiable data markets coordinated by protocol participants rather than a centralized backend..

Spread the word. Make sure you're in our community (and don't miss exciting updates): Discord | X | Telegram | GitHub | Website | LinkedIn

Three months after mainnet launch, the Powerloom Foundation unlocked its ecosystem fund. Today, we're announcing the very first recipient: BazaarX, a snapshotter delegation service.

A Different Approach to Ecosystem Grants

Most ecosystem grants chase potential—funding promises, pitches, and roadmaps from teams who haven't yet proven their commitment. We're taking a different path.

We're rewarding builders who already showed up.

Instead of attracting newcomers with future promises, we're backing the people who have already demonstrated their dedication to Powerloom.

Meet BazaarX: The First Community-Built Project on Powerloom

Our inaugural grant goes to the BazaarX ecosystem, led by noe1, one of our longest-standing community members.

What they built:

BazaarX repurposed Powerloom's open-source repositories to create a transparent snapshotter delegation platform. Users can delegate their snapshotter nodes to BazaarX, pay in $POWER and earn daily rewards without manual intervention.

Why this matters:

• First mover: BazaarX is literally the first community-run project on Powerloom
• True independence: Built and operated without any support from the Powerloom Foundation/core team
• Aligned incentives: They accept $POWER tokens for subscriptions on Powerloom Chain (our L2) aligning their success with the broader network
• Open participation: Anyone can delegate their nodes and participate as a snapshotter

This is exactly what decentralized infrastructure should enable — permissionless innovation by anyone, anywhere.

The Grant Details

BazaarX receives 1,000,000 POWER tokens conditional to them running a validator for the next 1 year, deepening their integration with the Powerloom network as we expand decentralization.

This grant reflects our commitment to those who build first and ask questions later.

Rewarding the Broader Community

The ecosystem grant isn't the only way we're recognizing our community.

The recently announced Snapshotter Rewards Program is distributing 10,000,000 POWER tokens to our loyal snapshotters who have been actively running their nodes since mainnet launch.

What This Means Going Forward

This first grant sets the precedent. The Powerloom ecosystem fund exists to amplify builders who have already proven their value — not to speculate on who might deliver someday.

If you're building on Powerloom, keep going. We're watching, and we're ready to support those who show up.

On Behalf of Powerloom Foundation

Links:

• BazaarX Platform
• Snapshotter Rewards Announcement

Spread the word. Make sure you’re in our community (and don’t miss exciting updates): Discord | Twitter | Telegram | Website | LinkedIn

With 6000+ nodes in the Powerloom network primed to deliver subsecond DeFi insights and earning rewards for accuracy, BDS breaks the mold of fixed data feeds by letting markets dynamically expand to cover any protocol, any chain, any metric - all verifiable on decentralized storage protocols like IPFS. This further bolsters the $POWER token ecosystem and sets the stage for trustless Web3 apps.

Why BDS Now? Tackling Web3's Data Challenges Head-On

Web3 promises decentralization, but most data providers still operate like traditional SaaS - centralized APIs serving stale or even worse, inaccurate indexes. Moreover, indexers simply listen for blockchain events tied to specific trading pairs, updating prices only when a trade occurs on that pair. Otherwise, the chart flatlines.

This works fine for stablecoin pairs, but for anything pegged to a volatile asset - like */WETH pairs - it's wildly inaccurate. Even if no trades happen on the pair for 100 blocks, ETH's price is fluctuating constantly, which should ripple through to the token's USD value. Without real-time adjustments, users get stale, misleading insights.

We've built BDS to overcome these hurdles, evolving from stable foundations to a fully decentralized powerhouse:

• Dynamic Accuracy: Real-time snapshots capture every shift
• Ironclad Verifiability: Proofs on decentralized storage protocols as well as anchors on Powerloom chain let anyone audit independently
• Agentic Infrastructure: Verifiable datasets that scale - from one MCP query to an entire ecosystem of agents consuming provable, consensus-backed data
• Scalable Design: Ever-expanding and new data sources being added dynamically

BDS is the first data market to leverage our Decentralized Sequencer-Validator (DSV) network, achieving what centralized providers can't: fast DeFi insights with zero trust assumptions. Dive into the DSV details here: Powerloom's Decentralized Sequencer-Validator Network Takes Shape

Demo: BDS in Action - See the Power

Jump into bds.powerloom.io and experience BDS firsthand!

Homepage: Your DeFi Hub

"Overview" pulses with live trades, top pools (like USDC/WETH at $99.47m), and tokens - filtered for 24h/1h/1m, all consensus-backed.

Dynamic Pools: activity based tracking

Pool Details: Real-Time Charts and Trades

See prices, charts (realtime dips/surges at every block with/without trades), TVL, volumes, and live transactions. BDS enabled you to accurately track a token’s price at each block even when a certain pool has no activity.

1-Click Verify

Recompute dashboard numbers using snapshot backlinks, stored on IPFS. Explore per-block snapshots, trades, and download 24h data dumps.

Agentic Infrastructure: Verifiable AI at Scale

Every BDS dataset comes with cryptographic proofs, enabling a new generation of trustless AI applications. Through MCP integration, agents don't just query data - they consume consensus-backed, verifiable datasets. One proven data source can power thousands of autonomous agents, each operating with complete confidence in data integrity. Query "24h volume on WETH/USDC?" and get not just an answer, but the onchain proof trail behind it.

Join the Movement: BDS Opens Up Soon

The transition to BDS marks a new chapter for the Powerloom ecosystem. We're preparing to open participation to our vibrant snapshotter community - those who've been the backbone of our mainnet operations.

• For Current Snapshotters: Watch out for our migration guide. Your experience with running nodes positions you perfectly for BDS's expanded data markets.
• For New Operators: Mint your own nodes and get ready to join when we open the gates. BDS offers multiple entry points based on your resources and interests.
• For Developers: Start exploring BDS datasets from any of the pools on the All Pools page. Build applications knowing your data foundation is verifiable and consensus-backed.

Pooler walked so BDS could run: Powerloom's Blockchain Data Service transforms decentralized data from promise to product, with subsecond updates and zero trust requirements.

Spread the word. Make sure you’re in our community (and don’t miss exciting updates): Discord | Twitter | Telegram | Website | LinkedIn

Today's update isn't just another development milestone. It's tangible proof that Powerloom is evolving from a promising protocol into production-ready infrastructure capable of powering real-time Web3 applications. We're laying the framework for our community to participate in this transformation through an experimental parallel network that demonstrates these capabilities without disrupting current operations.

🚀 From Bootstrap to Breakthrough: Why We're Decentralizing Now

Every successful protocol begins with tradeoffs. When Powerloom launched, we made a strategic decision: centralize the sequencer to ensure reliability while we built our snapshotter network. This approach worked — we now have thousands of snapshotters generating validated datapoints across thousands of DeFi data source contracts.

But we always knew this was temporary. A centralized sequencer, while functional, creates limitations we must overcome to achieve our vision:

Enhanced Reliability Through Redundancy: Multiple validators ensure the network continues operating even if individual nodes fail. No more single points of failure.

Verifiable Fairness: With decentralized consensus, every snapshot submission can be verified. The community can see exactly why snapshots are accepted or rejected — no black boxes.

Sustainable Economics: Moving from Foundation-subsidized rewards to protocol-native incentives creates a self-sustaining ecosystem where value flows from data consumers to data providers.

Unlimited Scalability: Decentralized architecture enables parallel processing across multiple datamarkets. Real-time DEX analytics, cross-chain monitoring, MEV detection — all running simultaneously without bottlenecks.

Community Ownership: Validators stake POWER and earn rewards for securing the network. The protocol becomes community-operated infrastructure, not Foundation-dependent.

These aren't just theoretical benefits. Our DSV network is already demonstrating these capabilities in testing. The results exceed our expectations.

⚡ The Decentralized Sequencer-Validator Network: Speed Meets Decentralization

For the past six months, our engineering team has been building a decentralized sequencer-validator (DSV) network that eliminates every limitation of centralized sequencing while achieving something remarkable: subsecond propagation across a global peer-to-peer network.

This isn't an incremental improvement. It's an architectural transformation.

🔄 The Core Innovation: Decentralized Consensus at Wire Speed

Traditional blockchain consensus is slow because it prioritizes security over speed. Data protocols can't afford that luxury — DeFi applications need real-time data, not data from ten blocks ago. The DSV network achieves both security and speed through a novel approach:

Mesh Network: Instead of hub-and-spoke communication through a central sequencer, validators form a peer-to-peer mesh. Snapshot submissions propagate across this mesh in milliseconds, not seconds.

Parallel Consensus Tracks: Rather than sequential consensus rounds, validators run parallel tracks for different data types. Uniswap pool states don't wait for Aave liquidation data. Each datamarket operates independently.

Subsecond Propagation: Through optimized gossipsub protocols and strategic peer connections, the network achieves near instant consensus and subsecond propagation for most snapshots. This isn't theoretical — we're measuring it in our test deployments.

💰 Our Vision For Economic Transformation: Beyond Daily Subsidies

The DSV network decentralizes economic value as well as technical infrastructure.

🌱 Sustainable Validator Economics

Validators stake POWER tokens and earn from two sources:

• Protocol rewards for honest participation
• Transaction fees from data consumers

This creates genuine economic activity, not subsidized participation.

🛡️ Eliminating Censorship Risk

With multiple validators competing for snapshots, censorship becomes economically irrational. Reject valid snapshots? Another validator will accept them and earn the rewards.

🔓 Permissionless Datamarket Creation

Anyone should be able to launch a datamarket in the near future by attracting validators with appropriate incentives. No permission needed from the Foundation. No central gatekeeping.

This is how Powerloom becomes the data layer for Web3 — not through central planning but through permissionless innovation.

🧪 Joining The Experimental DSV Network

We will soon be opening up the experimental DSV network for community participation. This network runs parallel to our current operations—zero risk to existing rewards or operations.

✅ What This Means

For Current Snapshotters: Continue normal operations. Optionally connect to DSV endpoints to help test the network. Your rewards continue unchanged.

For POWER Holders: Observe real performance comparisons between centralized and decentralized approaches. Prepare for validator opportunities in the coming months.

For Developers: Access our complete codebase, run your own test validators, and contribute improvements. Every component is open source.

⚠️ What This Doesn't Mean

This is NOT a mainnet-ready launch. The upcoming experimental network is for testing and optimization.

Current operations are NOT changing. The centralized sequencer continues operating normally for now.

Rewards are NOT affected. Snapshotters continue earning as usual.

Watch out for our next series of blog posts that will contain

• Technical deep dives on the DSV network. Existing docs here: github.com/powerloom/snapshot-sequencer-validator
• Details on joining the parallel experimental DSV network
• Detailed roadmap

Join the technical discussion on Discord | Follow development updates @Powerloom

This is a development update, not a launch announcement. The experimental network runs parallel to current operations with zero impact on existing rewards or functionality.

Spread the word. Make sure you’re in our community (and don’t miss exciting updates): Discord | Twitter | Telegram | Website | LinkedIn

The wait is over. After months of development, we’re excited to announce that Powerloom Devnet is now live, providing developers with a complete replica of our mainnet functionality in a risk-free environment.

What is Powerloom Devnet?

Devnet provides developers with a sandbox environment to build and test rich data applications on top of smart contracts and popular DeFi protocols like Uniswap and Aave. Running on an Arbitrum Nitro testnet chain powered by Conduit, it’s a complete replica of our mainnet functionality—but with zero cost and zero risk.

What You Can Build

• Analytics Dashboards: Visualize onchain data in real-time
• Arbitrage Bots: Test trading strategies with dummy tokens
• Wallet Trackers: Monitor and analyze wallet activity

Current Support

Devnet currently supports Ethereum data collection, with specific implementations for:

• Uniswap V2: Complete DEX data tracking
• Aave V3: Lending protocol analytics

Zero-Cost Testing

Everything on Devnet is free:

• Get test tokens from our faucet
• Mint node slots without cost
• Experiment with protocol mechanics
• Test applications before mainnet deployment

Why Devnet Changes Everything

For New Developers: Learn Powerloom’s protocol without pressure. Understand node operations, data processing, and market creation through hands-on experience.

For Experienced Teams: Rapidly prototype new concepts, test integrations, and validate ideas before committing resources to Mainnet deployment.

For Researchers: Access a controlled environment perfect for academic research, algorithm testing, and data science experiments.

Get Started in 3 Simple Steps

Ready to dive in? Getting started with Devnet is quick and straightforward:

1. Get Free Tokens: Visit devnet-faucet.powerloom.dev to claim your test tokens
2. Mint Your Node: Head to devnet-mint.powerloom.dev to mint a node slot
3. Start Snapshotting: Follow our setup guide to begin collecting and processing data

📖 Access Complete Documentation →

What’s Next?

This is just the beginning. With Devnet, we’re empowering developers to explore the full potential of onchain data without barriers. Whether you’re building dashboards, testing arbitrage strategies, or creating entirely new data markets—the tools are now in your hands.

Join our #developer channel on Discord and share what you’re building. The best innovations come from developers who aren’t afraid to experiment.

Spread the word. Make sure you’re in our community (and don’t miss exciting updates): Discord | Twitter | Telegram | Website | LinkedIn

It was an unfortunate decision, especially with the Ethereum Pectra upgrade just around the corner. Sticking to the OP Stack after this would have had an unsustainable impact on our protocol, the associated operators, and users.

Migrating our chain was the only option. And we chose Arbitrum Nitro as the new stack for Powerloom L2.

Powerloom’s growth continues post-migration, and we’re proud of our core devs and engineering team for pulling off one of crypto’s smoothest chain migrations. There was minimal downtime, and it required only two user actions:

1. Snapshotters had to update their nodes
2. L2 $POWER holders had to move their unstaked balances manually

Everything else — Snapshotter NFTs, unclaimed Daily Rewards, staked $POWER, etc. — was migrated automatically. Here’s the story of how all this was accomplished.

The Preparations

Finalizing Arbitrum Nitro required a week of thoroughly weighing alternatives, confirming Offchain Labs’ long-term commitment towards custom gas tokens, and aligning our partners: Conduit, Relay, BlockVigil, and others.

This overlapped with the final stages of our protocol audit.

Completing the audit bolstered Powerloom’s security and resilience. But all states and user flows to be affected by the migration had to be mapped to the audited contracts — 2x work for our core devs.

From integrating audited contracts to identifying states to be migrated and functions to be written, every step had to be meticulously planned. It was crucial to ensure that we:

1. Rigorously test and verify all components involved in the migration, down to specific user variables (more on that later)
2. Determine the exact order in which different states need to be migrated: Snapshotter State → Protocol State → Data Market State → Staking Contract
3. Define clear and distinct transition points so that our team and community can transparently monitor progress on the day of migration

TL;DR of our complete migration timeline:

1. Major Operational Freeze (~24 hours before Epoch 55,000)
2. Network State Freeze (Epoch 55,000)
3. State Transition Window (~6 hours)
4. V2 Chain Switchover
5. Protocol State Preservation

With our core devs owning the biggest transitions, the migration timeline was followed down to the T on D-Day.

Uninterrupted Snapshotter Operations

Almost the entire state for the protocol state contracts had to be migrated. Yet node operations didn’t face any downtime, except during the State Transition Window.

Snapshotters simply had to update their nodes to the latest version (v2.7.0) which we released on March 17, 2025 — ten days before the migration. The release included a patcher that triggered a switchover of the node to use the upgraded chain’s RPC, protocol state, and data market contracts as soon as Epoch 55000 was detected. That’s as seamless as it gets.

Operators continued earning Daily Rewards on the old chain until the Network State Freeze. Their updated nodes automatically switched over to connect to the new chain at Epoch 55,000 and resumed submissions once the first V2 epoch (ID: 55,001) was released.

The decoupled sequencer framework — which we perfected and shipped in 2024 — enabled the low-effort migration for snapshotters.

It has multiple moving parts deployed in a Kubernetes orchestration environment for high availability and fault tolerance. This architecture allowed the sequencer to maintain a steady and constant connection with snapshotter nodes so they could continue running.

The $POWER Migration Bridge

Besides snapshotters updating their nodes, only one other user action was required in the entire migration process.

Users had to manually move their unstaked L2 $POWER balances from Mainnet V1 (old chain) to Mainnet V2 (new chain). We built a custom bridge for this purpose.

While the bridge allowed L2 $POWER holders to move their funds in five simple steps, building it was an extremely complicated process. For example:

• Adequate liquidity had to be provided to ensure fast and reliable transfers, even during peak user activity
• Transactions had to be balanced on both ends to eliminate double spending or any loss of users’ funds

The fact that entire companies are in the business of building bridges speaks volumes about the challenges of doing so. Achieving this with our internal tooling was a milestone in itself.

Building the bridge wasn’t all though. We ran at least four to five simulations on Devnet to ensure that it was secure and functioning as intended.

Verifying and Migrating the Mainnet State

Launched on January 9, the Powerloom Mainnet ran on the old chain for over two months. Node minting, staking, burning, and other operations were active even until 24 hours prior to the migration. Tons of data had been generated during this time, including:

• Eligible nodes for 77 days of running the Uniswap V2 data market
• 2317 active slots (nodes) with non-zero rewards
• 2494 unique user addresses and 5863 slots IDs
• 283 user addresses for Node Staking and 241 burned nodes

We had to migrate this entire state to Mainnet V2. And unlike, say, moving information from one Notion database or Google Sheets to another, there’s no copy-paste in onchain state migrations.

Migration and verification scripts had to be written for each state: minted nodes, unclaimed rewards, etc. — i.e., everything that was ‘automatically migrated’ from the users’ PoV.

These scripts had to be tested extensively through multiple simulations on both Devnet and Testnet. Once everything looked good there, the Mainnet state had to be moved to the Devnet for more rounds of testing and verification.

During the State Transition Window on migration day, our core devs ran and monitored the tested scripts to migrate the entire protocol state, including user balances, stakes, and rewards.

This herculean task was completed in under six hours and without a glitch — thanks to all the extra hours put in by our engineering team, planning and testing everything to this end.

Releasing the First V2 Epoch — The Way Forward

The first Mainnet V2 epoch (ID: 55,001) was released around 14:30 UTC on March 27, 2025. The new chain was live, powered by Arbitrum Nitro and managed by Conduit. This was the beginning of Powerloom’s next phase.

Almost 2000 active nodes started submitting to the V2 chain immediately after the first epoch release. Minting, staking, and rewards claims also went back up soon after.

Normal operations had resumed on Powerloom. Our community could freely use native L2 $POWER — while experiencing the enhanced performance and stability offered by the V2 upgrade.

For example, the Mainnet V2 Bridge is 7x faster, letting users withdraw $POWER from L2 to L1 within 24 hours, not seven days.

Node Staking has also reached new heights on our migrated L2 chain, further testifying the non-disruptive nature of the migration.

Working around the clock for over two weeks, our core devs and engineering team retained all historic data, so that the new chain could pick up exactly where the old one stopped.

Except for the necessary downtime, users didn’t face any gaps or disruptions. We provided clear instructions and in-depth guides for every step. And we ‘migrated in public’, letting anyone monitor/track our plan, progress, and the results.

Spread the word. Make sure you’re in our community (and don’t miss exciting updates): Discord | Twitter | Telegram | Website | LinkedIn

Now you can contribute to the Powerloom network and earn rewards with any amount of POWER. Even if you don’t have enough to mint a new node.

👉 Start here: https://mint.powerloom.network/staking

We’re building an ecosystem where anyone can contribute to the future of onchain data access, not just as consumers but also as operators.

Node Staking is a step in this direction — the first of its kind.

It doesn’t matter if your POWER balance is low. You can start with as little as 1 POWER and earn a share of the Daily Rewards in proportion to your contribution.

How Node Staking Works

The NodeStaking contract lets users deposit POWER into an onchain pool.

It automatically mints one node whenever available staked tokens in the pool match the node mint price — 10,000 POWER at the time of writing this. These minted nodes are run on an infrastructure operated by the Powerloom Foundation.

Participating in the pool entitles you to a share of the Daily Rewards earned by the minted nodes, based on the amount of tokens you stake.

Your rewards are distributed once every 720 epochs approx. (~24 hours), similar to Snapshotters running their nodes on Mainnet.

Rewards Calculation & Fees

Node Staking rewards are based on the following parameters:

• Total staked POWER in the pool
• Your contribution — i.e., how much POWER you staked
• Performance of minted nodes and their eligibility for Daily Rewards
• The current rate of Daily Rewards for the specific data market on a given day

Example: Suppose you and two of your friends are the only participants in the pool, and you’ve deposited 1000, 5000, and 7000 POWER, respectively. Thus, the pool has 13,000 staked POWER, and your contribution is ~7.6% of the total amount. Now, on a day when the total reward is, say, 15,000, you’ll get 7.6% of 15,000 = 1,140 POWER. On this day, your friends will get 5,760 POWER and 8,070 POWER, respectively.

Fee on rewards: You’ll pay a fee on the rewards earned through Node Staking (30% at the time of writing), which is deducted automatically while claiming. 

❗Claimable Rewards = Earned Rewards - Current Fees

The fees will incentivize node operations while supporting the growth and stability of the Daily Rewards pool. It will also ensure that the system remains fair towards existing Snapshotters, and running your own node will continue to be more profitable overall.

How to Stake & Start Earning Rewards

First, visit https://mint.powerloom.network/staking

You can check your POWER Balance after connecting the wallet. If you don’t have any, click ‘Get POWER’ to acquire some. Skip this step if you’re already a POWER holder.

Enter your desired amount and click ‘Stake’. This’ll initiate the process and prompt you to sign a transaction on the connected wallet.

The confirmation takes a few seconds, and you’re done.

Your Staked Balance will reflect immediately, while your accumulated rewards will show up in the $POWER Earned section. The latter might take a day or two.

Claiming Rewards

Click ‘Claim’ to redeem your earned rewards. Here you have two options:

1. Claim & Stake — The claimed amount will be automatically re-staked in a single transaction. We recommend this as it gives you the benefits of compounding on your staking rewards.

2. Claim — If, however, you only wish to claim, toggle the ‘Stake’ option and click ‘Claim’. This will deposit the claimed tokens into your connected wallet.

Unstaking & Withdrawal

If you wish to stop participating in Node Staking at any point, you can withdraw your deposited POWER by clicking ‘Unstake’.

Then enter the amount you want to withdraw and click ‘Start Withdrawal’. Sign the transaction in your wallet to confirm.

Your withdrawn tokens will be available for claiming once the network cooldown period (7 days at the time of writing) expires.

This is necessary for the contract to properly unwind node positions. It also prevents attacks and ensures network security.

Click ‘Finish Claim’ after the cooldown to receive POWER in your wallet.

Maximizing Returns on Node Operations

We’re dedicated to maximizing benefits for our community.

That’s why we have features like Claim & Stake, which provides a risk-minimized way to keep growing your initial stake without additional capital requirements.

If you’re looking for a super low-cost entry into Powerloom’s distributed data economy, Node Staking is perfect for you.

🔗 👉 Start TODAY! Join our mission of making accurate and affordable onchain data accessible to everyone in Web3 💪 🚀

Spread the word. Make sure you’re in our community (and don’t miss exciting updates): Discord | Twitter | Telegram | Website | LinkedIn

📖 To know more about minting and running YOUR OWN nodes on Powerloom Mainnet, read this blog post or check out our in-depth docs.

Moving ahead, we’re ready to open up the network for new snapshotters (i.e., node operators) to further expand Powerloom’s capacity to deliver composable onchain datasets for next-gen web3 apps and consumers.

Existing snapshotters — who are already running their nodes on Mainnet — can also start claiming Daily Rewards from a daily pool of 50,000 POWER. Or they can burn their slots to claim the unlocked portion of their staked POWER allocation.

Let’s break down the processes for both, highlighting the critical aspects you need to keep in mind.

👉 Tip: Open https://mint.powerloom.network/ on the side to follow along.

Details for Existing Snapshotters

This section is for our Testnet phase node mint participants who already have Slot IDs and can run their nodes on Powerloom Mainnet.

As an existing snapshotter, you have two options:

a. Run your nodes on Powerloom Mainnet to earn Daily Rewards

b. Burn your slot(s) to claim the unlocked portion of your staked POWER allocation (available for KYC-ed participants ONLY)

Earning Daily Rewards

Powerloom network currently has a daily pool of 50,000 POWER tokens to incentivize active snapshotters and reward them for their critical contributions to Powerloom’s distributed data economy.

Tokens from this pool will be distributed equally among eligible participants as Daily Rewards after every 720 epochs (i.e., roughly 24 hours). You can track and claim your Daily Rewards from the Snapshotter Dashboard.

Eligibility Criteria: Currently, nodes that submit at least 1000 snapshots per day are eligible for Daily Rewards. You can check your eligibility on a given day (720 epochs) from the Dashboard. Notably, however, the minimum snapshot requirement may change in the future, according to protocol requirements.

If you still haven’t updated your nodes to run on Mainnet, check out our official docs for setup instructions.

Start today, so you don’t miss out on any more Daily Rewards!

Claiming Unlocked POWER

Powerloom has allocated 3800 staked POWER for EACH existing node. You can claim an unlocked portion of this allocation, subject to the following criteria.

For KYC-ed operators:

• 10% of the allocation (i.e., 380 POWER) is now unlocked, with a 12-month linear vesting for the remaining 90% with a one month cliff.
• To claim (withdraw) any portion of this unlocked POWER, you need to burn your node(s) and give up the ability to run it on Mainnet.
• By burning your node, you’ll immediately receive 380 POWER in your connected wallet, but you can no longer earn Daily Rewards.
• The remaining 90% will be vested as per schedule, even for those who claim now and burn their nodes/slots as specified above.

For node holders/operators who are NOT KYC-ed, 100% of the staked POWER allocation (3800) will unlock after 12 months. You cannot burn your nodes/slots before that. However, any daily Mainnet rewards you earn is fully unlocked - make sure to run your node!

Details for New Node Operators

This section is for those who want to secure a fresh Slot ID to run their nodes on Powerloom Mainnet.

Powerloom Mainnet is now open for new snapshotters to join, so they can earn Daily Rewards while contributing to the mission of making affordable, accurate, and verifiable onchain data accessible to everyone in web3.

To join, you first need to bridge POWER from Ethereum, either by using:

a. Our native OP bridge

b. The third-party bridge powered by our partner, Relay Protocol which has a tiny fee but does allow swapping other assets from multiple chains directing to Powerloom mainnet!

Regardless of the bridge, make sure you to get a additional bit (~0.001) of POWER for gas usage for mainnet operations.

After bridging POWER, you need to:

• Go to https://mint.powerloom.network/
• Mint a slot by staking 10K POWER

Once the mint is successfully completed, you can start participating in Powerloom’s distributed data economy.

To manage your slot and track/claim Daily Rewards, use our Snapshotter Dashboard.

If you need any help while setting up or running your node(s), feel free to drop a query in our official Discord server — our active, inclusive community is always ready to support you.

Further, you can read our in-depth docs for a more holistic understanding of the protocol’s architecture, processes, flows, etc.

What’s Next?

Currently, in the initial rollout phase, Powerloom Mainnet is only incentivizing submissions for the Uniswap V2 data market, as mentioned in our official announcement. During this phase, we are closely tracking metrics like incoming snapshotter connections and snapshotting capacity.

Based on these observations we shall ensure optimal rewards distribution upon re-introducing support for multiple data markets, including Uniswap V3 and Aave V3, as soon as the network gains a bit more stability.

As showcased through extensive participation and testing by our global snapshotter community during the Pre-Mainnet phase, multiple data markets help maximize rewards for snapshotters by giving them access to multiple revenue streams.

Moreover, we also plan to implement dynamic data markets, giving consumers and end-users more control over the market creation process.

A new phase in onchain data access has only just begun — there’s a long journey ahead. Make sure you’re an active part of this revolution, as some of you always have been.

Stay tuned for more exciting updates.

POWER up to shape the future of onchain data access 🚀💪

Join our community: Discord | Twitter | Telegram | Website | LinkedIn

We reached this milestone through countless all-nighters by the team, extensively testing and optimizing the protocol through our pre-Mainnet phase, along with constant, invaluable support from our community’s legends.

With deep gratitude towards all our community members, we now march ahead toward our mission of making accurate, reliable, and verifiable onchain data accessible to everyone.

Powerloom’s composable data network is designed to make accessing onchain data as easy and affordable as buying a bottle of water. And when consumers (devs, orgs, and end-users) get rich insights about tokens, decentralized social interactions, etc., without spending loads of cash or hours of effort, next-gen web3 innovations will flourish. That’s our vision — our promise.

What’s New (and Better)

• The highly performant Local Collector included in the Mainnet release of the Lite node can handle hundreds of concurrent computes submitted to it and writes to the Sequencer without a glitch.
• The Multi-Node Setup Framework will further simplify the process of running Powerloom nodes, with features like one-command setup, cleanup and diagnostics, and slot selection.

Besides these, the latest Lite node release features multiple improvements to functionalities like tighter integration of snapshot computes and configs with the built images of the snapshotter Docker containers, as well as granular namespacing of snapshot projects that further supports cross-chain use cases.

Powerloom Mainnet can also support multiple data markets. However, in the initial phase, it will only incentivize Uniswap V2 submissions by default.

The multi-data market support will go live once the network stabilizes, reintroducing Uniswap V3 and Aave V3 markets, as well as adding new markets. This will maximize revenue streams and the opportunity to earn rewards for node operations. Consumers will also get more control over market creation with upcoming features like dynamic data markets.

Empowering Snapshotters

We are never tired of acknowledging the critical role Snapshotters play within the Powerloom ecosystem. They set our solution apart from any other, and their contributions are pivotal to disrupting the typical indexing-oriented approach to onchain data access.

Thus, similar to Testnet, the initial phase of the Mainnet launch is focused on empowering our 5300+ global Snapshotter community and onboarding new members to reach the 10,000 mark.

How to Participate

Existing Snapshotters—i.e., node mint participants with a Slot ID—who joined the network when we announced the simulation setup on Discord and prepared their nodes for the Mainnet transition should already start seeing submissions on the Powerloom Snapshotter Dashboard.

If you haven’t updated your setup, we encourage you to do so by following the steps outlined in the Node Setup Instructions shared on our official Discord channel.

Snapshotters who have already setup their nodes to run on the Mainnet can start claiming their rewards after the POWER tokens unlock on January 10, 2025. At this point, new node operators will also be able to join by staking 10,000 POWER to secure their Slot IDs.

Notably, existing Snapshotters who fully or partially unstake/withdraw their allocation of 3800 POWER tokens — 10% unlocked at TGE for KYCed participants, followed by a 12-month linear vesting — will burn their slots (i.e., lose their Slot IDs) and won’t be able to run their nodes. To rejoin the network, they would have to stake 10,000 POWER, just like any other new entrant.

To know more about the Snapshotter node implementation or how to set it up, check out our detailed documentation:

• Snapshotter Lite V2
• Snapshotter Lite Multi-Setup
• Complete Snapshotter Node Docs

Powering Next-gen Web3 Innovations

The architecture supporting our Mainnet has matured significantly through a year of testing and iterative development. Built on a performant L2 using the OP Stack and EigenDA, it delivers optimal uptime, scalability, and efficiency. With this robust foundation now live, we can confidently expand Powerloom's feature set and capabilities

From introducing Validators and Watchmen to strengthen the integrity of datasets and network security as a whole to facilitating fully demand-driven data markets with roles like Curators, we have big things planned for the road ahead.

With products like Generative Prediction Markets (GPM) or our self-hosted DeFi dashboards for Uniswap V2/V3 and Aave V3, we have already showcased Powerloom’s potential and scope over the past year.

After today’s Mainnet launch, we embark on the real journey of opening up the network for generations of next-gen Web3 consumer apps and users to leverage and derive value from.

So, if you are ready for hassle-free, cost-effective, yet reliable access to decentralized onchain insights, you’re ready for Powerloom. We’re here to catalyze futuristic innovations across web3 ecosystems, from DeFi to DeSoc, DePIN, and DeAI.

Leveraging a robust yet flexible infra, Powerloom will cater to all kinds of onchain data needs, no matter how diverse, extensive, or complex.

Power UP, and join the revolution as we transform onchain data access. 💪 🚀

Spread the word. Make sure you’re in our community (and don’t miss exciting updates): Discord | Twitter | Telegram | Website | LinkedIn

Through extensive testing and community feedback during the Testnet phases, we discovered the need to deploy our upcoming Mainnet on a mature architecture that’s robust, scalable, and flexible at once.

Leveraging Conduit’s innovative Rollup-as-a-Service (RaaS) paradigm let us achieve this purpose, without any excessive additions to our production and development costs and efforts.

Thanks to their modular, customizable offerings, we shipped a performant and resilient L2 based on the OP Stack. We’re confident in this chain’s ability to handle over billions of daily snapshots that we expect our Mainnet to eventually generate across protocols and blockchain ecosystems.

Further, true to our vision for optimal verifiability, accessibility, and uptime, we’re using EigenDA as the data availability layer for Powerloom Chain.

It allows us to inherit the decentralized security of the settlement layer — i.e., the Ethereum Mainnet — while achieving the high throughput and reliability necessary for complex use-cases like our Uniswap V2/V3 and Aave V3 dashboards for next-gen consumer apps like Generative Prediction Markets (GPM).

Powerloom chain is now available on Conduit Hub. Here’s a quick overview of the key details:

Our Mainnet — the culmination of everything we achieved since 2020 — drops in three days, built on such robust foundations.

Get ready to experience a hassle-free and cost-efficient way of consuming web3 data, whether you are building next-gen apps or using them.

We have tons of exciting news lined up: Mainnet details, TGE date, and more.

Stay tuned, stay POWERed. 🫡 🚀