Amp · by Edge & Node

Amp is a blockchain-native database

A high performance, SQL-native, blockchain-specific database, integrating any chain's data with all your existing systems, and supporting realtime and analytics use-cases.

0x41c0f38be9df0x94d27c7948760xd43fdaa455320x2af5839ebee20x6952fe3bd6b80xb9bf4d86fa910x06de625beacd0x463ba3d979530x9598f3633b090xd5f54f3a2bbc0x2452ae30c53d0x74bffc5f1dfe0xb31c5b7ba3d30x0389a988128b0x42e6f7a581420x924356c3f0060xe1a0a4e06fdb0x210d109daedd0x716a5131b5e20xb0da54844aa40x0035759273e60x5f915c729b120x9ffeab9ff96c0xee5b0b86670b0x41c0f38be9df0x94d27c7948760xd43fdaa455320x2af5839ebee20x6952fe3bd6b80xb9bf4d86fa910x06de625beacd0x463ba3d979530x9598f3633b090xd5f54f3a2bbc0x2452ae30c53d0x74bffc5f1dfe0xb31c5b7ba3d30x0389a988128b0x42e6f7a581420x924356c3f0060xe1a0a4e06fdb0x210d109daedd0x716a5131b5e20xb0da54844aa40x0035759273e60x5f915c729b120x9ffeab9ff96c0xee5b0b86670b

Own the pipeline

You control the extraction and every step after it, end to end, on infrastructure you choose.

Integrate with your stack

Standard SQL over Arrow Flight, plus export jobs into Snowflake and Postgres, and more!

Scale across chains and use cases

Any EVM chain plus Solana, with more chains added all the time. The same tables serve realtime and analytics workloads.

Pull any chain into the tools you already run.

Amp extracts every block, transaction, and log from the chains you point it at, keeps them as Parquet in your bucket, and serves them as SQL to whatever you query with today.

extract and verifyquery or stream

Ethereum

Base

Solana

Arbitrum

Optimism

Polygon

AmpParquet in your bucketSQL over Arrow Flight

Snowflake

ClickHouse

Postgres

Databricks

Apache Kafka

Grafana

EthereumBaseSolanaArbitrumOptimismPolygon

↓ extract and verify

Amp

↓ query or stream

SnowflakeClickHousePostgresDatabricksApache KafkaGrafana

Is it for me?

Pick your team and see what Amp does for it.

Chain data you query in SQL and plug into the pipelines you already run.

Every chain is a set of tables, queryable in standard SQL over Arrow Flight from any client that speaks it.
Schedule it from the orchestrator you already use, and land results in Snowflake, Postgres, or Polars.
Transformations are SQL that Amp keeps up to date block by block, so they live next to the data.
The same binary runs on your laptop and as a shared instance in your cloud or on-prem.

transfers.py

1from amp import Client2 3amp = Client("grpc+tls://gateway.amp.edgeandnode.com")4 5transfers = amp.sql("""6    SELECT block_num, tx_hash, address AS token7    FROM mainnet.logs8    WHERE topic0 = evm_topic('Transfer(address indexed from, address indexed to, uint256 value)')9      AND _block_num > 2100000010""")11 12df = transfers.to_polars()13transfers.load(connection=sf, destination="raw.transfers")

Your own SQL over every chain, from the tools you already use.

Write custom SQL and run it from a console, a notebook, or the BI tool of your choice.
Materialize a query as a dataset in Amp and it stays current block by block.
Or pipe the results into the analytics system your team already reports from.
Pin a revision and last quarter's number comes back the same every time.

usdc.py

1import polars as pl2 3SIG = "Transfer(address indexed from, address indexed to, uint256 value)"4 5transfers = amp.sql(f"""6    SELECT timestamp,7           evm_decode_hex(dec['from']) AS sender,8           evm_decode_hex(dec['to'])   AS receiver,9           dec['value']::double / 1e6  AS usdc10    FROM (11        SELECT l.*, evm_decode(l.topic1, l.topic2, l.topic3, l.data, '{SIG}') AS dec12        FROM mainnet.logs l13        WHERE l.address = 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb4814          AND l.topic0  = evm_topic('{SIG}')15          AND l._block_num > 2100000016    )17""").to_polars()18 19daily = (20    transfers21    .group_by(pl.col("timestamp").dt.truncate("1d").alias("day"))22    .agg(pl.col("usdc").sum().alias("volume"), pl.len().alias("transfers"))23    .sort("day")24)

chart.py

1import altair as alt2 3alt.Chart(daily).mark_bar().encode(4    x="day:T",5    y=alt.Y("volume:Q", title="USDC transferred"),6    tooltip=["day:T", "volume:Q", "transfers:Q"],7)

Extract your protocol's data in minutes, and share it however you prefer.

Point Amp at your chain or your contracts and the data is tables, with no custom indexer to write.
Decode your contracts' events at query time, or materialize them as a dataset that stays current.
Publish a versioned dataset to partners, serve it over SQL, or export it into the tools they already run.
Forks roll back on their own, so ecosystem dashboards stay correct at the head.

your-chain.toml

1kind = "evm-rpc"2network = "your-chain"3url = "https://rpc.your-chain.example.com"

1SELECT block_num, evm_decode_log(topic1, topic2, topic3, data,2  'Deposit(address indexed user, uint256 amount)') AS deposit3FROM "you/your_chain".logs4WHERE topic0 = evm_topic('Deposit(address indexed user, uint256 amount)')

How does it work? From a chain to the tools you run

Connect your data sources

A provider tells Amp where to read a chain from: your own node or an RPC vendor. Credentials stay with the operator as ${VAR} references, and a provider can be swapped without touching anything downstream.

mainnet.toml

1kind = "evm-rpc"2network = "mainnet"3url = "${ETH_RPC_URL}"

1ampctl provider register mainnet_rpc ./mainnet.toml

Index raw chain data

A raw dataset extracts every block, transaction, and log into Parquet, backfills from a start block, then follows the chain head under a second behind it, correct through reorgs.

1ampctl manifest generate --kind evm-rpc --network mainnet --out eth_mainnet.json2ampctl dataset register acme/eth_mainnet ./eth_mainnet.json --tag 1.0.03ampctl dataset deploy acme/eth_mainnet@1.0.0

1+------------------+-------------------------------+2| column_name      | data_type                     |3+------------------+-------------------------------+4| block_num        | UInt64                        |5| timestamp        | Timestamp(Nanosecond, +00:00) |6| hash             | FixedSizeBinary(32)           |7| parent_hash      | FixedSizeBinary(32)           |8| miner            | FixedSizeBinary(20)           |9| gas_used         | UInt64                        |10| base_fee_per_gas | Decimal128(38, 0)             |11+------------------+-------------------------------+1219 more columns, plus transactions and logs

Transform it with SQL

A derived dataset is a SQL query Amp keeps updated block by block. Decode events, join, aggregate, and version the result like any other dataset.

transfers.sql

1SELECT l.block_num, l.timestamp, t.symbol,2       evm_decode_hex(dec['from']) AS sender,3       evm_decode_hex(dec['to'])   AS receiver,4       dec['value']::double / pow(10, t.decimals) AS amount5FROM (6    SELECT *, evm_decode(topic1, topic2, topic3, data, 'Transfer(address indexed from, address indexed to, uint256 value)') AS dec7    FROM "acme/eth_mainnet".logs8    WHERE topic0 = evm_topic('Transfer(address indexed from, address indexed to, uint256 value)')9) l10JOIN "acme/stablecoins".tokens t ON t.address = l.address

1+-----------+--------+-------------+-------------+-----------+2| block_num | symbol | sender      | receiver    | amount    |3+-----------+--------+-------------+-------------+-----------+4| 25931398  | USDC   | 0x28c6…21a4 | 0x7a25…0f91 | 250000.00 |5| 25931398  | USDT   | 0xf977…9ff9 | 0x1ab4…ce10 | 18400.50  |6| 25931399  | USDC   | 0x4d9f…77c4 | 0x28c6…21a4 | 999.99    |7+-----------+--------+-------------+-------------+-----------+

Connect your internal systems

Join chain data with the reference data you already hold, and deliver the result to Snowflake or Postgres through an ADBC export job, exactly once, reorgs included.

1amp.sql(q).load(connection=sf, destination="raw.transfers")

1for result in amp.sql("SELECT * FROM mainnet.blocks").load(2    connection="warehouse", destination="eth_blocks", stream=True3):4    if result.is_reorg:5        print(f"reorg: rolled back {len(result.invalidation_ranges)} block ranges")6    else:7        print(f"+{result.rows_loaded} rows")

1> SELECT * FROM raw.transfers LIMIT 3;2+-----------+-------------+-------------+3| BLOCK_NUM | TX_HASH     | TOKEN       |4|-----------+-------------+-------------|5|  25931398 | 0x6f2c…91ab | 0xa0b8…eb48 |6|  25931398 | 0x0d47…3e10 | 0xdac1…1ec7 |7|  25931399 | 0xb81e…77c4 | 0xc02a…6cc2 |8+-----------+-------------+-------------+

Query and visualize

Standard SQL over Arrow Flight, from a console, a notebook, a BI tool, or Polars. Swap the LIMIT for SETTINGS stream = true and the same statement streams in block order.

1SELECT block_num, tx_hash, address AS token2FROM "acme/eth_mainnet".logs3WHERE topic0 = evm_topic('Transfer(address indexed from, address indexed to, uint256 value)')4LIMIT 5

1+-----------+-------------+-------------+2| block_num | tx_hash     | token       |3+-----------+-------------+-------------+4| 25931398  | 0x6f2c…91ab | 0xa0b8…eb48 |5| 25931398  | 0x0d47…3e10 | 0xdac1…1ec7 |6| 25931399  | 0xb81e…77c4 | 0xc02a…6cc2 |7| 25931399  | 0x2a9f…d005 | 0xa0b8…eb48 |8| 25931400  | 0xe53b…0f9e | 0xdac1…1ec7 |9+-----------+-------------+-------------+

Monitor freshness and performance

Sync progress, distance to the chain head, storage, and job health come from the Admin API. ampctl shows the same numbers in the terminal, and OpenTelemetry carries them into Grafana.

1ampctl dataset status acme/eth_mainnet@1.0.0

1Status:   Running2Kind:     Raw3Dataset:  acme/eth_mainnet@1.0.04 5Table         Synced through   Distance to head   Storage6blocks        25931403         1 block            18.2 GiB7transactions  25931403         1 block            211.6 GiB8logs          25931403         1 block            164.9 GiB

Chain agnostic: Any EVM chain plus Solana, with more chains added all the time. A provider is one TOML file.
SQL-first: Standard SQL over Arrow Flight, with ABI, Borsh, SCALE, and XDR decoded at query time.
Integrate with your stack: Arrow in Polars, export jobs into Snowflake and Postgres, and any client that speaks Arrow Flight SQL.
Self-host or run it with us: Run it in your cloud or on-prem, or the same binary run for you by Edge & Node.
Low latency: Under a second behind the chain head, correct through reorgs.
Minimal footprint: Two services to run besides ampd. Parquet at rest is 10× smaller than BigQuery's Solana dataset.

Correct through forks, bad data, and time.

Forks roll back on their own

Hash-linked ranges detect the fork, drop the orphaned blocks, and replay the canonical ones.

Bad RPC data never lands

With --verify, Amp recomputes header hashes and Merkle roots. A bad RPC response fails instead of landing in a table.

Last quarter's number, every time

Datasets are immutable revisions. Query as of a pinned revision and get the same answer every time.

Learn more

Plugs into the stack you already run.

Snowflake, BigQuery, ClickHouse, Postgres, Kafka, and the rest of the tools your data team works in.