diff --git a/docs/blockchain/arc-testnet/arc-testnet-balances-api.md b/docs/blockchain/arc-testnet/arc-testnet-balances-api.md new file mode 100644 index 00000000..abe05b07 --- /dev/null +++ b/docs/blockchain/arc-testnet/arc-testnet-balances-api.md @@ -0,0 +1,368 @@ +--- +title: "Arc Testnet Balances & Token Supply API" +description: "Query wallet balances, balance history and token total supply on Circle's Arc testnet with Bitquery GraphQL: full portfolios, multi-wallet batches, per-token balance changes and TransactionBalances supply." +sidebar_position: 6 +keywords: + - Arc testnet balances API + - Arc testnet wallet balance + - Arc testnet USDC balance + - Arc testnet portfolio API + - Arc testnet balance history + - Arc testnet token supply + - Arc testnet eth_getBalance alternative + - Circle Arc balances API + - arc_testnet Balances + - Bitquery Arc testnet +--- +# Arc Testnet Balances & Token Supply API + +Query **wallet balances and token supply on Arc testnet** with Bitquery GraphQL. Three cubes on `network: arc_testnet` cover it: + +| Cube | What it returns | +| --- | --- | +| `Balances` | Computed current balance per address and currency, with first and last change time and update count | +| `BalanceUpdates` | Every individual balance change, with the transaction that caused it | +| `TransactionBalances` | Per-transaction post-balances and the token's `TotalSupply` | + +Every query on this page was executed against the production endpoint before publishing. + +:::warning Testnet limits +- `...InUSD` fields are **0**. Value holdings with the [latest price query](/docs/blockchain/arc-testnet/arc-testnet-trades-api/#latest-price-of-a-token) if you need a dollar figure. +- Only `dataset: realtime` exists; leave the `dataset` argument out. +- The token-centric **`Holders`** cube is not available on Arc testnet because it is served from the archive dataset. Sum `BalanceUpdates` per address, as in [top holders of a token](#top-holders-of-a-token), for holder rankings within the realtime window. +::: + +:::note API Key Required +To query or stream data outside the Bitquery IDE, you need an API access token. + +Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorization/how-to-generate/) +::: + +:::tip Related docs +- [Arc Testnet API overview](/docs/blockchain/arc-testnet/) — network facts, every cube and stream in one place +- [Arc Testnet Transfers API](/docs/blockchain/arc-testnet/arc-testnet-transfers-api/) +- [Arc Testnet DEX Trades API](/docs/blockchain/arc-testnet/arc-testnet-trades-api/) +- [EVM Balances schema](/docs/schema/evm/balances/) +- [EVM Token Supply API](/docs/blockchain/Ethereum/token-supply/evm-token-supply/) +::: + +**On this page:** [Portfolio](#portfolio-of-a-wallet) · [One token](#balance-of-one-token) · [Batch](#balances-of-several-wallets) · [Top holders](#top-holders-of-a-token) · [History](#balance-history-of-a-wallet) · [Stream](#stream-balance-changes) · [Supply](#total-supply-of-a-token) · [Supply stream](#stream-supply-changes) · [FAQ](#faq) + +--- + +## Portfolio of a wallet + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-wallet-portfolio) + +Every currency an address holds, with the computed balance and when it last changed. Native USDC has `Native: true`; the ERC-20 interface at `0x3600...` is listed separately. + +```graphql +{ + EVM(network: arc_testnet) { + Balances( + where: {Balance: {Address: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}}} + orderBy: {descending: Balance_Amount} + ) { + Currency { + Name + Symbol + SmartContract + Native + } + Balance { + Amount + FirstChangeTime + LastChangeTime + UpdateCount + } + } + } +} +``` + +--- + +## Balance of one token + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-balance-of-one-token) + +The `balanceOf` equivalent for ERC-20 USDC. For the gas token use `Currency: {Native: true}` instead of a contract filter. + +```graphql +{ + EVM(network: arc_testnet) { + Balances( + where: { + Balance: {Address: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}} + Currency: {SmartContract: {is: "0x3600000000000000000000000000000000000000"}} + } + ) { + Currency { + Symbol + Decimals + } + Balance { + Amount + LastChangeTime + } + } + } +} +``` + +--- + +## Balances of several wallets + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-balances-of-several-wallets) + +One call for a batch of addresses, grouped by address and currency. + +```graphql +{ + EVM(network: arc_testnet) { + Balances( + where: { + Balance: { + Address: { + in: [ + "0x2de8906a641d65d490bc60a4179d961d59742bcb" + "0x73742278c31a76dbb0d2587d03ef92e6e2141023" + "0x49f9636fe15883e16d5e356a4ea08c9fe6bc219b" + ] + } + } + Currency: {SmartContract: {is: "0x3600000000000000000000000000000000000000"}} + } + orderBy: {descending: Balance_Amount} + ) { + Balance { + Address + Amount + } + Currency { + Symbol + } + } + } +} +``` + +--- + +## Top holders of a token + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-top-holders-of-a-token) + +Addresses ranked by their net balance change of one token, summed from `BalanceUpdates`. On the testnet this reflects changes inside the realtime window rather than a full-chain snapshot, so treat it as a leaderboard of active holders. The top row is usually the Uniswap v4 PoolManager, which holds pool reserves. + +```graphql +{ + EVM(network: arc_testnet) { + BalanceUpdates( + where: { + Currency: {SmartContract: {is: "0xe2cfd2893ad90e8a5b4f87c5cad22d150b1e12a0"}} + } + orderBy: {descendingByField: "balance"} + limit: {count: 20} + ) { + BalanceUpdate { + Address + } + balance: sum(of: BalanceUpdate_Amount) + updates: count + } + } +} +``` + +--- + +## Balance history of a wallet + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-balance-history) + +Each change to a wallet's ERC-20 USDC balance, newest first, with the transaction behind it. Positive amounts are inflows. + +```graphql +{ + EVM(network: arc_testnet) { + BalanceUpdates( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + BalanceUpdate: {Address: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}} + Currency: {SmartContract: {is: "0x3600000000000000000000000000000000000000"}} + } + ) { + Block { + Number + Time + } + Transaction { + Hash + } + BalanceUpdate { + Amount + Type + } + Currency { + Symbol + } + } + } +} +``` + +### Net change per currency over a window + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-balance-net-change) + +Sum the updates per currency to see what a wallet gained or lost over the last 24 hours. + +```graphql +{ + EVM(network: arc_testnet) { + BalanceUpdates( + where: { + BalanceUpdate: {Address: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}} + Block: {Time: {since_relative: {hours_ago: 24}}} + } + orderBy: {descendingByField: "netChange"} + ) { + Currency { + Symbol + SmartContract + Native + } + netChange: sum(of: BalanceUpdate_Amount) + inflow: sum(of: BalanceUpdate_Amount, if: {BalanceUpdate: {Amount: {gt: "0"}}}) + outflow: sum(of: BalanceUpdate_Amount, if: {BalanceUpdate: {Amount: {lt: "0"}}}) + updates: count + } + } +} +``` + +--- + +## Stream balance changes + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-stream-balance-updates) + +Every balance change of a wallet as it happens. Widen the filter to a list of addresses or a single token to build alerts. + +```graphql +subscription { + EVM(network: arc_testnet) { + BalanceUpdates( + where: { + BalanceUpdate: {Address: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}} + } + ) { + Block { + Number + Time + } + Transaction { + Hash + } + BalanceUpdate { + Amount + Type + } + Currency { + Symbol + SmartContract + Native + } + } + } +} +``` + +--- + +## Total supply of a token + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-token-total-supply) + +`TransactionBalances` records the token's total supply after each transaction that touched it. The latest row is the current supply, already adjusted for decimals. + +```graphql +{ + EVM(network: arc_testnet) { + TransactionBalances( + limit: {count: 1} + orderBy: {descending: Block_Time} + where: { + TokenBalance: { + Currency: {SmartContract: {is: "0xe2cfd2893ad90e8a5b4f87c5cad22d150b1e12a0"}} + } + } + ) { + Block { + Time + } + TokenBalance { + Currency { + Symbol + SmartContract + } + TotalSupply + } + } + } +} +``` + +--- + +## Stream supply changes + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-stream-token-supply) + +A new row arrives whenever a mint or burn changes the supply of the token. + +```graphql +subscription { + EVM(network: arc_testnet) { + TransactionBalances( + where: { + TokenBalance: { + Currency: {SmartContract: {is: "0xe2cfd2893ad90e8a5b4f87c5cad22d150b1e12a0"}} + } + } + ) { + Block { + Time + } + Transaction { + Hash + } + TokenBalance { + Currency { + Symbol + } + TotalSupply + } + } + } +} +``` + +--- + +## FAQ + +**Why is the `Holders` cube missing?** +`Holders` is built from the archive dataset, and the testnet has none. Rank holders by summing `BalanceUpdates` per address within the realtime window, as shown above. Arc mainnet will have the full cube. + +**Why does the same wallet show USDC twice?** +Native USDC (`Native: true`, 18 decimals) and the ERC-20 USDC interface (`0x3600...`, 6 decimals) are tracked as two currencies. Sum them yourself if you want one USDC figure. A third row with contract `0xfff...fffe` and no symbol is a system ledger mirror and can be ignored. + +**Are USD values available?** +No. Every `...InUSD` field is 0 on the testnet. Because most balances are dollar stablecoins, `Amount` is usually the figure you want anyway. + +**Is `TotalSupply` raw or decimal-adjusted?** +Decimal-adjusted. A token with a billion supply reads `1000000000.000000000000000000`. diff --git a/docs/blockchain/arc-testnet/arc-testnet-calls-api.md b/docs/blockchain/arc-testnet/arc-testnet-calls-api.md new file mode 100644 index 00000000..45eb76f3 --- /dev/null +++ b/docs/blockchain/arc-testnet/arc-testnet-calls-api.md @@ -0,0 +1,431 @@ +--- +title: "Arc Testnet Calls & Traces API" +description: "Query and stream smart contract calls and internal traces on Circle's Arc testnet with Bitquery GraphQL: method calls by selector, internal calls of a transaction, contract deployments, reverts and top methods." +sidebar_position: 4 +keywords: + - Arc testnet calls API + - Arc testnet internal transactions + - Arc testnet traces API + - Arc testnet contract deployments + - Arc testnet debug_traceTransaction alternative + - Arc testnet reverted calls + - Circle Arc calls API + - arc_testnet Calls + - Bitquery Arc testnet +--- +# Arc Testnet Calls & Traces API + +Query and stream **smart contract calls on Arc testnet** with Bitquery GraphQL. The `EVM.Calls` cube on `network: arc_testnet` holds every call in every transaction, including internal calls, with the decoded method signature, the call path, value, gas, success and revert flags, and the enclosing transaction. It returns what `debug_traceTransaction` and `trace_filter` return, without running a node, and the same query runs as a subscription. + +Every query on this page was executed against the production endpoint before publishing. Change `query` to `subscription` on any of them to stream the same rows. + +:::warning Testnet: realtime only, USD fields are 0 +Only `dataset: realtime` exists for Arc testnet; leave the `dataset` argument out. `Call.ValueInUSD` and the transaction `...InUSD` fields return 0. +::: + +:::note API Key Required +To query or stream data outside the Bitquery IDE, you need an API access token. + +Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorization/how-to-generate/) +::: + +:::tip Related docs +- [Arc Testnet API overview](/docs/blockchain/arc-testnet/) — network facts, every cube and stream in one place +- [Arc Testnet Events API](/docs/blockchain/arc-testnet/arc-testnet-events-api/) +- [Arc Testnet Transactions API](/docs/blockchain/arc-testnet/arc-testnet-transactions-api/) +- [EVM Calls schema](/docs/schema/evm/calls/) +- [Transfers vs Events vs Calls](/docs/start/mental-model-transfers-events-calls/) +::: + +**On this page:** [Call anatomy](#what-one-call-row-contains) · [Stream](#stream-calls-to-a-contract) · [Latest](#latest-calls) · [By method](#calls-of-one-method) · [By selector](#calls-by-4-byte-selector) · [Internal calls of a transaction](#internal-calls-of-a-transaction) · [Deployments](#contract-deployments) · [Reverts](#reverted-calls) · [Top methods](#most-called-methods) · [Value-carrying calls](#calls-that-move-native-usdc) · [FAQ](#faq) + +--- + +## What one call row contains + +| Group | What it gives you | +| --- | --- | +| `Call` | `From`, `To`, `Value`, `Input`, `Output`, `Gas`, `GasUsed`, `Success`, `Reverted`, `Error`, `Create`, `Delegated`, `SelfDestruct`, `CallPath`, `Index`, `Depth` | +| `Call.Signature` | `Name`, full `Signature`, `SignatureHash` (the 4-byte selector, without `0x`) | +| `Arguments` | Decoded, typed inputs for registered ABIs | +| `Transaction` | Hash, `From`, `To`, value, gas and fee fields | +| `Receipt` | `Status`, `GasUsed`, deployed `ContractAddress` | +| `Block` | `Number`, `Time` | + +A transaction's top-level call has `Call.Index` 0 and an empty `CallPath`; internal calls have deeper paths. Filter `Call: {Index: {eq: 0}}` when you want one row per transaction. + +### Example addresses on this page + +| Item | Address | +| --- | --- | +| Uniswap v4 PoolManager | `0x1d70945634f618eefdf9edaadb59b9a183cef929` | +| USDC (ERC-20) | `0x3600000000000000000000000000000000000000` | + +--- + +## Stream calls to a contract + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-stream-calls-to-contract) + +Every call into the Uniswap v4 PoolManager, internal or top-level, as it happens. + +```graphql +subscription { + EVM(network: arc_testnet) { + Calls( + where: {Call: {To: {is: "0x1d70945634f618eefdf9edaadb59b9a183cef929"}}} + ) { + Block { + Number + Time + } + Transaction { + Hash + From + } + Call { + From + To + Value + Success + CallPath + Signature { + Name + Signature + SignatureHash + } + } + } + } +} +``` + +--- + +## Latest calls + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-latest-calls) + +The most recent top-level calls, one per transaction. + +```graphql +{ + EVM(network: arc_testnet) { + Calls( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: {Call: {Index: {eq: 0}}} + ) { + Block { + Number + Time + } + Transaction { + Hash + } + Call { + From + To + Value + Success + Gas + GasUsed + Signature { + Name + SignatureHash + } + } + } + } +} +``` + +--- + +## Calls of one method + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-calls-of-a-method) + +Filter on the decoded method name and the contract. This reads `transfer` calls into the ERC-20 USDC contract with their decoded arguments. + +```graphql +{ + EVM(network: arc_testnet) { + Calls( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + Call: { + To: {is: "0x3600000000000000000000000000000000000000"} + Signature: {Name: {is: "transfer"}} + } + } + ) { + Block { + Time + } + Transaction { + Hash + } + Call { + From + Success + Signature { + Signature + } + } + Arguments { + Name + Value { + ... on EVM_ABI_Address_Value_Arg { + address + } + ... on EVM_ABI_BigInt_Value_Arg { + bigInteger + } + } + } + } + } +} +``` + +--- + +## Calls by 4-byte selector + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-calls-by-selector) + +When the ABI is not registered, filter on the selector in `Call.Input` instead. This matches `approve(address,uint256)` by its `0x095ea7b3` prefix on any contract. + +```graphql +{ + EVM(network: arc_testnet) { + Calls( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: {Call: {Input: {startsWith: "0x095ea7b3"}}} + ) { + Block { + Time + } + Transaction { + Hash + } + Call { + From + To + Input + Success + Signature { + Name + } + } + } + } +} +``` + +--- + +## Internal calls of a transaction + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-internal-calls-of-transaction) + +The full call tree of one transaction, ordered by call index. Replace the hash with any recent transaction from the [Transactions API](/docs/blockchain/arc-testnet/arc-testnet-transactions-api/). + +```graphql +{ + EVM(network: arc_testnet) { + Calls( + orderBy: {ascending: Call_Index} + where: { + Transaction: { + Hash: {is: "0x9be99a14a7db15fae9b78c68c3bfb41cfd67654a7b8cdf499f56e712d8349fe1"} + } + } + ) { + Call { + Index + Depth + CallPath + From + To + Value + Gas + GasUsed + Success + Reverted + Delegated + Signature { + Name + Signature + } + } + } + } +} +``` + +--- + +## Contract deployments + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-contract-deployments) + +`Call.Create: true` marks a call that deployed a contract. The new address is in `Receipt.ContractAddress` for top-level deployments; for factory deployments read `Call.To` on the create call. + +```graphql +{ + EVM(network: arc_testnet) { + Calls( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: {Call: {Create: true}} + ) { + Block { + Time + Number + } + Transaction { + Hash + From + } + Call { + From + To + Success + CallPath + } + Receipt { + ContractAddress + } + } + } +} +``` + +--- + +## Reverted calls + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-reverted-calls) + +Calls that reverted, with the error string when the EVM returned one. Useful for debugging a contract under test. + +```graphql +{ + EVM(network: arc_testnet) { + Calls( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: {Call: {Reverted: true}} + ) { + Block { + Time + } + Transaction { + Hash + From + } + Call { + From + To + Error + CallPath + Signature { + Name + } + } + } + } +} +``` + +--- + +## Most called methods + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-most-called-methods) + +Method signatures ranked by call count over 24 hours. ERC-20 `transfer`, `balanceOf` and `approve` dominate, followed by Uniswap v4 hook callbacks. + +```graphql +{ + EVM(network: arc_testnet) { + Calls( + limit: {count: 20} + orderBy: {descendingByField: "count"} + where: { + Block: {Time: {since_relative: {hours_ago: 24}}} + Call: {Signature: {Name: {not: ""}}} + } + ) { + Call { + Signature { + Name + Signature + SignatureHash + } + } + count + contracts: uniq(of: Call_To) + } + } +} +``` + +--- + +## Calls that move native USDC + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-calls-with-value) + +Internal calls that carried native USDC value. This is how value moves between contracts shows up, since those movements are not ERC-20 `Transfer` events. + +```graphql +{ + EVM(network: arc_testnet) { + Calls( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: {Call: {Value: {gt: "10"}}} + ) { + Block { + Time + } + Transaction { + Hash + } + Call { + From + To + Value + Index + Signature { + Name + } + } + } + } +} +``` + +--- + +## FAQ + +**How do I get one row per transaction?** +Filter `Call: {Index: {eq: 0}}`. Every other row is an internal call. + +**Why is `Signature.Name` empty on some calls?** +The ABI is not registered. The raw `Input` and the selector prefix are still there, so filter with `Input: {startsWith: ...}`, and ask support to register the ABI if you need decoded arguments. + +**Is `Call.Value` in USDC?** +Yes. The gas token on Arc is USDC, so `Call.Value` and `Transaction.Value` are native USDC amounts. `ValueInUSD` is 0 on testnet even though the value is dollar-denominated. + +**Does this replace `debug_traceTransaction`?** +For call trees, yes: `CallPath`, `Depth`, `Index`, gas per call and revert reasons are all here. Opcode-level traces are not. + +**Can I read calls older than the realtime window?** +Not on the testnet; only `dataset: realtime` exists. diff --git a/docs/blockchain/arc-testnet/arc-testnet-events-api.md b/docs/blockchain/arc-testnet/arc-testnet-events-api.md new file mode 100644 index 00000000..119cd205 --- /dev/null +++ b/docs/blockchain/arc-testnet/arc-testnet-events-api.md @@ -0,0 +1,519 @@ +--- +title: "Arc Testnet Events API & WebSocket Streams" +description: "Stream every smart contract event on Circle's Arc testnet with Bitquery GraphQL: decoded logs by contract, signature, topic0 or argument, plus Uniswap v4 Initialize, v3 PoolCreated and v2 PairCreated feeds." +sidebar_position: 3 +keywords: + - Arc testnet events API + - Arc testnet smart contract events + - Arc testnet logs API + - Arc testnet eth_getLogs alternative + - Arc testnet event stream websocket + - Arc testnet Uniswap v4 Initialize + - Arc testnet new pools + - Circle Arc events API + - arc_testnet Events + - Bitquery Arc testnet +--- +# Arc Testnet Events API & WebSocket Streams + +Stream **every smart contract event on Arc testnet** with Bitquery GraphQL. The `EVM.Events` cube on `network: arc_testnet` returns each log with decoded, typed arguments for known signatures, the raw topics, and the transaction, internal call and receipt that produced it. It covers what `eth_getLogs` and `eth_subscribe("logs")` return, and adds server-side filtering on decoded values. + +Every query on this page was executed against the production endpoint before publishing. Change `query` to `subscription` on any of them to stream the same rows. + +:::warning Testnet: realtime only, USD fields are 0 +Only `dataset: realtime` exists for Arc testnet; leave the `dataset` argument out. `Transaction.ValueInUSD`, `Call.ValueInUSD` and the gas `...InUSD` fields return 0. +::: + +:::note API Key Required +To query or stream data outside the Bitquery IDE, you need an API access token. + +Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorization/how-to-generate/) +::: + +:::tip Related docs +- [Arc Testnet API overview](/docs/blockchain/arc-testnet/) — network facts, every cube and stream in one place +- [Arc Testnet Calls API](/docs/blockchain/arc-testnet/arc-testnet-calls-api/) +- [Arc Testnet DEX Trades API](/docs/blockchain/arc-testnet/arc-testnet-trades-api/) +- [Arc Testnet Transfers API](/docs/blockchain/arc-testnet/arc-testnet-transfers-api/) +- [EVM Events schema](/docs/schema/evm/events/) +- [Transfers vs Events vs Calls](/docs/start/mental-model-transfers-events-calls/) +::: + +**On this page:** [Event anatomy](#what-one-event-row-contains) · [Firehose](#stream-all-events) · [By contract](#events-from-one-contract) · [By signature](#one-event-across-all-contracts) · [By topic0](#filter-by-raw-topic0) · [By argument](#filter-by-a-decoded-argument) · [New v4 pools](#new-uniswap-v4-pools) · [New v3 and v2 pools](#new-uniswap-v3-and-v2-pools) · [Busiest contracts](#busiest-contracts-and-signatures) · [Undecoded events](#undecoded-events) · [FAQ](#faq) + +--- + +## What one event row contains + +| Group | What it gives you | +| --- | --- | +| `Log` | `SmartContract` (the code that produced the log), log `Index`, and `Signature` (`Name`, full `Signature`, `SignatureHash`) | +| `LogHeader` | `Address`, the emitting address as `eth_getLogs` would return it | +| `Topics` | The raw indexed topics; topic0 is the signature hash | +| `Arguments` | Decoded, typed values (`address`, `bigInteger`, `string`, `hex`, `bool`, `integer`) with names | +| `Transaction` | Hash, `From`, `To`, value, gas and fee fields | +| `Call` | The internal call that emitted the log, with its signature and success flags | +| `Receipt` | `GasUsed`, `CumulativeGasUsed`, deployed `ContractAddress` | +| `Block` | `Number`, `Time` | + +Hash fields (`SignatureHash`, `Topics.Hash`) are hex strings **without** a `0x` prefix. + +### Example addresses on this page + +| Item | Address | +| --- | --- | +| Uniswap v4 PoolManager | `0x1d70945634f618eefdf9edaadb59b9a183cef929` | +| Uniswap v3 factory (busiest `PoolCreated` emitter) | `0x0fb6eeda6e90e90797083861a75d15752a27f59c` | +| Uniswap v2 factory (busiest `PairCreated` emitter) | `0xd67f63a4f26a497b364d1c82e6747aec8b5743a5` | +| USDC (ERC-20) | `0x3600000000000000000000000000000000000000` | +| EURC | `0x89b50855aa3be2f677cd6303cec089b5f319d72a` | + +--- + +## Stream all events + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-stream-all-events) + +One socket, every event on the chain. Good for building an indexer; heavy for anything else, so use the filtered streams below in production. + +```graphql +subscription { + EVM(network: arc_testnet) { + Events { + Block { + Number + Time + } + Transaction { + Hash + From + To + } + LogHeader { + Address + } + Log { + Index + Signature { + Name + Signature + SignatureHash + } + } + Topics { + Hash + } + Arguments { + Name + Type + Value { + ... on EVM_ABI_Integer_Value_Arg { + integer + } + ... on EVM_ABI_String_Value_Arg { + string + } + ... on EVM_ABI_Address_Value_Arg { + address + } + ... on EVM_ABI_BigInt_Value_Arg { + bigInteger + } + ... on EVM_ABI_Bytes_Value_Arg { + hex + } + ... on EVM_ABI_Boolean_Value_Arg { + bool + } + } + } + } + } +} +``` + +--- + +## Events from one contract + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-events-from-a-contract) + +`LogHeader.Address` is the `address` filter of `eth_getLogs`. This reads the latest events of the ERC-20 USDC contract. + +```graphql +{ + EVM(network: arc_testnet) { + Events( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + LogHeader: {Address: {is: "0x3600000000000000000000000000000000000000"}} + } + ) { + Block { + Time + } + Transaction { + Hash + } + Log { + Signature { + Name + } + } + Arguments { + Name + Value { + ... on EVM_ABI_Address_Value_Arg { + address + } + ... on EVM_ABI_BigInt_Value_Arg { + bigInteger + } + } + } + } + } +} +``` + +--- + +## One event across all contracts + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-swap-events) + +Filter by decoded signature name to watch one event type from every contract that emits it. This catches every `Swap`, from Uniswap v2 pairs, v3 pools and the v4 PoolManager alike. + +```graphql +{ + EVM(network: arc_testnet) { + Events( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: {Log: {Signature: {Name: {is: "Swap"}}}} + ) { + Block { + Time + } + Transaction { + Hash + } + LogHeader { + Address + } + Log { + Signature { + Signature + } + } + Arguments { + Name + Value { + ... on EVM_ABI_Address_Value_Arg { + address + } + ... on EVM_ABI_BigInt_Value_Arg { + bigInteger + } + ... on EVM_ABI_Bytes_Value_Arg { + hex + } + } + } + } + } +} +``` + +--- + +## Filter by raw topic0 + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-events-by-topic0) + +When you have the signature hash rather than the name, filter on `Log.Signature.SignatureHash`. This is the ERC-20 `Transfer(address,address,uint256)` hash, written without `0x`. + +```graphql +{ + EVM(network: arc_testnet) { + Events( + limit: {count: 10} + orderBy: {descending: Block_Time} + where: { + Log: { + Signature: { + SignatureHash: {is: "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"} + } + } + } + ) { + Block { + Time + } + Transaction { + Hash + } + LogHeader { + Address + } + Topics { + Hash + } + Arguments { + Name + Value { + ... on EVM_ABI_Address_Value_Arg { + address + } + ... on EVM_ABI_BigInt_Value_Arg { + bigInteger + } + } + } + } + } +} +``` + +--- + +## Filter by a decoded argument + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-events-by-argument) + +Server-side filtering on decoded values is what a node cannot do. This finds every event whose argument named `to` equals a wallet, across all contracts and signatures. + +```graphql +{ + EVM(network: arc_testnet) { + Events( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + Arguments: { + includes: { + Name: {is: "to"} + Value: {Address: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}} + } + } + } + ) { + Block { + Time + } + Transaction { + Hash + } + LogHeader { + Address + } + Log { + Signature { + Name + } + } + Arguments { + Name + Value { + ... on EVM_ABI_Address_Value_Arg { + address + } + ... on EVM_ABI_BigInt_Value_Arg { + bigInteger + } + } + } + } + } +} +``` + +--- + +## New Uniswap v4 pools + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-new-uniswap-v4-pools) + +Uniswap v4 carries most of the testnet's swaps. A new pool is an `Initialize` event on the PoolManager; its arguments give the pool `id`, the two currencies, the fee tier, tick spacing, hook address and opening price. `currency0` of the zero address means native USDC. + +```graphql +{ + EVM(network: arc_testnet) { + Events( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + LogHeader: {Address: {is: "0x1d70945634f618eefdf9edaadb59b9a183cef929"}} + Log: {Signature: {Name: {is: "Initialize"}}} + } + ) { + Block { + Time + Number + } + Transaction { + Hash + From + } + Arguments { + Name + Type + Value { + ... on EVM_ABI_Address_Value_Arg { + address + } + ... on EVM_ABI_BigInt_Value_Arg { + bigInteger + } + ... on EVM_ABI_Integer_Value_Arg { + integer + } + ... on EVM_ABI_Bytes_Value_Arg { + hex + } + } + } + } + } +} +``` + +Change `query` to `subscription` and drop `limit` and `orderBy` to get each new pool the moment it is created. + +--- + +## New Uniswap v3 and v2 pools + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-new-v3-v2-pools) + +Several v3 and v2 factory deployments exist on the testnet, so filter on the event name rather than one factory address. `PoolCreated` is v3, `PairCreated` is v2; both carry the two tokens and the new pool address in their arguments. + +```graphql +{ + EVM(network: arc_testnet) { + Events( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: {Log: {Signature: {Name: {in: ["PoolCreated", "PairCreated"]}}}} + ) { + Block { + Time + } + Transaction { + Hash + } + LogHeader { + Address + } + Log { + Signature { + Name + } + } + Arguments { + Name + Value { + ... on EVM_ABI_Address_Value_Arg { + address + } + ... on EVM_ABI_BigInt_Value_Arg { + bigInteger + } + ... on EVM_ABI_Integer_Value_Arg { + integer + } + } + } + } + } +} +``` + +--- + +## Busiest contracts and signatures + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-busiest-event-contracts) + +Which contracts and event types dominate the log stream over 24 hours. Run this first on any network you have not explored yet. + +```graphql +{ + EVM(network: arc_testnet) { + contracts: Events( + limit: {count: 10} + orderBy: {descendingByField: "count"} + where: {Block: {Time: {since_relative: {hours_ago: 24}}}} + ) { + LogHeader { + Address + } + count + } + signatures: Events( + limit: {count: 10} + orderBy: {descendingByField: "count"} + where: {Block: {Time: {since_relative: {hours_ago: 24}}}} + ) { + Log { + Signature { + Name + Signature + } + } + count + } + } +} +``` + +--- + +## Undecoded events + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-undecoded-events) + +Events whose ABI is not registered arrive with an empty `Signature.Name` and no `Arguments`, but the raw `Topics` and `Log.SmartContract` are still there. This lists the contracts emitting the most undecoded events; if one matters to you, ask support to register its ABI. + +```graphql +{ + EVM(network: arc_testnet) { + Events( + limit: {count: 10} + orderBy: {descendingByField: "count"} + where: { + Block: {Time: {since_relative: {hours_ago: 24}}} + Log: {Signature: {Name: {is: ""}}} + } + ) { + LogHeader { + Address + } + Topics { + Hash + } + count + } + } +} +``` + +--- + +## FAQ + +**How do I map my `eth_getLogs` filter?** +`address` becomes `LogHeader.Address`, `topics[0]` becomes `Log.Signature.SignatureHash` (without `0x`), and a fixed block range becomes a `Block.Number` filter. Everything else on this page is extra: decoded arguments, argument filters and joined transaction context. + +**`LogHeader.Address` or `Log.SmartContract`?** +`LogHeader.Address` is the emitting address. `Log.SmartContract` is the code that produced the log, which differs behind proxies. Filter on `LogHeader.Address` to watch a deployed address. + +**Why do some events have an empty name?** +Their ABI is not registered yet. The raw topics and data are still delivered. See [Undecoded events](#undecoded-events). + +**Can I get history beyond the realtime window?** +Not on the testnet; only `dataset: realtime` exists. + +**How do I follow one Uniswap v4 pool?** +Take the pool `id` from its `Initialize` event and filter `Swap` events on the PoolManager whose first argument (`id`) matches it, using the [argument filter](#filter-by-a-decoded-argument) with `Value: {Bytes: ...}`, or read the pool's trades through the [DEX Trades API](/docs/blockchain/arc-testnet/arc-testnet-trades-api/) by its two currencies. diff --git a/docs/blockchain/arc-testnet/arc-testnet-trades-api.md b/docs/blockchain/arc-testnet/arc-testnet-trades-api.md new file mode 100644 index 00000000..d696c8d4 --- /dev/null +++ b/docs/blockchain/arc-testnet/arc-testnet-trades-api.md @@ -0,0 +1,554 @@ +--- +title: "Arc Testnet DEX Trades API & Streams" +description: "Query and stream Uniswap v2, v3, v4 and Curve trades on Circle's Arc testnet with Bitquery GraphQL: live swaps, latest trades, OHLCV candles, top tokens, DEX breakdown and trader activity." +sidebar_position: 1 +keywords: + - Arc testnet trades API + - Arc testnet DEX trades + - Arc testnet Uniswap v4 trades + - Arc testnet OHLCV + - Arc testnet token price + - Arc testnet swap stream + - Circle Arc DEX API + - Arc blockchain trades API + - arc_testnet DEXTrades + - arc_testnet DEXTradeByTokens + - Bitquery Arc testnet +--- +# Arc Testnet DEX Trades API & Streams + +Query and stream **DEX trades on Arc testnet** with Bitquery GraphQL. Arc is Circle's EVM Layer 1 for stablecoin finance, and its testnet is exposed as `EVM(network: arc_testnet)`. The `DEXTrades` and `DEXTradeByTokens` cubes carry every swap on **Uniswap v4, v3 and v2, Curve and Aerodrome** with buy and sell sides, native-unit prices, the DEX contract, the trader and the transaction. + +Every query on this page was executed against the production endpoint before publishing. Change `query` to `subscription` on any of them to stream the same rows over WebSocket. + +:::warning Testnet: no USD values, no Trading cube, realtime only +- Every `...InUSD` field (`AmountInUSD`, `PriceInUSD`, `ValueInUSD`) returns **0** on Arc testnet. There is no token price index for a testnet. Prices in `Trade.Price` and `Trade.PriceInUSD` are ratios of the two sides and work normally. +- The multi-chain `Trading` cubes (`Trading.Trades`, `Tokens`, `Pairs`) do **not** include Arc testnet. Use the chain-level `DEXTrades` and `DEXTradeByTokens` cubes on this page. +- Only `dataset: realtime` (the default) is served. There is no archive for the testnet, so leave the `dataset` argument out. + +USD pricing and an archive dataset are planned for Arc **mainnet** once it is indexed. +::: + +:::note API Key Required +To query or stream data outside the Bitquery IDE, you need an API access token. + +Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorization/how-to-generate/) +::: + +:::tip Related docs +- [Arc Testnet API overview](/docs/blockchain/arc-testnet/) — network facts, every cube and stream in one place +- [Arc Testnet Transfers API](/docs/blockchain/arc-testnet/arc-testnet-transfers-api/) +- [Arc Testnet Events API](/docs/blockchain/arc-testnet/arc-testnet-events-api/) — Uniswap v4 `Initialize`, v3 `PoolCreated`, v2 `PairCreated` +- [Arc Testnet Balances API](/docs/blockchain/arc-testnet/arc-testnet-balances-api/) +- [DEXTrades vs DEXTradeByTokens vs Trading.Trades](/docs/cubes/dextrades-dextradebytokens-trading-trades/) +- [EVM DEXTrades schema](/docs/schema/evm/dextrades/) +::: + +**On this page:** [Identifiers](#network-and-example-addresses) · [Stream](#stream-real-time-trades) · [Latest](#latest-trades) · [By token](#trades-of-a-token) · [By DEX](#trades-on-one-dex) · [By pool](#trades-in-one-pool) · [By trader](#trades-of-a-wallet) · [OHLCV](#ohlcv-candles-for-a-token) · [Latest price](#latest-price-of-a-token) · [Top tokens](#most-traded-tokens) · [DEX breakdown](#trade-count-by-dex-protocol) · [Top traders](#most-active-traders) · [FAQ](#faq) + +--- + +## Network and example addresses + +| Item | Value | +| --- | --- | +| Network argument | `EVM(network: arc_testnet)` | +| Chain ID | `5042002` | +| Native gas token | USDC. Appears as `SmartContract: "0x0000000000000000000000000000000000000000"` with symbol `USDC` and name `USD Coin` in `DEXTrades` and `DEXTradeByTokens`; as `"0x"` with `Currency.Native: true` in `Transfers` and `Balances` | +| USDC (ERC-20 interface, 6 decimals) | `0x3600000000000000000000000000000000000000` | +| EURC (6 decimals) | `0x89b50855aa3be2f677cd6303cec089b5f319d72a` | +| USDT (testnet mock, 18 decimals) | `0x175cdb1d338945f0d851a741ccf787d343e57952` | +| ARCFOMO (busiest meme token at the time of writing) | `0xe2cfd2893ad90e8a5b4f87c5cad22d150b1e12a0` | +| Uniswap v4 PoolManager | `0x1d70945634f618eefdf9edaadb59b9a183cef929`, the `Dex.SmartContract` on every v4 trade | +| Uniswap v3 USDC/USDT pool | `0x715f78de0cea7428a5ede4a0c491b05e7a8caff2` | +| Uniswap v3 EURC/USDT pool | `0x66a038f2f6000cf42d34c3ccd6c97ccfa16443bd` | + +These are live examples. Testnet tokens come and go, so swap in any token, pool or trader you care about. + +:::info Uniswap v4 pools have no address +On v4 every pool lives inside the singleton PoolManager, so `Trade.Dex.SmartContract` is the PoolManager and `Trade.Dex.Pair.SmartContract` is the zero address. Identify a v4 pool by its two currencies, or by the `id` argument of the `Initialize` event on the [Events API](/docs/blockchain/arc-testnet/arc-testnet-events-api/#new-uniswap-v4-pools). +::: + +--- + +## Stream real-time trades + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-stream-dex-trades) + +One WebSocket delivers every swap on the network as blocks are indexed, with both sides, the protocol and the trader. + +```graphql +subscription { + EVM(network: arc_testnet) { + DEXTrades { + Block { + Number + Time + } + Transaction { + Hash + From + } + Trade { + Dex { + ProtocolFamily + ProtocolName + SmartContract + } + Buy { + Amount + Buyer + Seller + Price + Currency { + Name + Symbol + SmartContract + } + } + Sell { + Amount + Buyer + Seller + Price + Currency { + Name + Symbol + SmartContract + } + } + } + } + } +} +``` + +--- + +## Latest trades + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-latest-dex-trades) + +The most recent swaps on the network. `Trade.Buy` is the currency the trader received and `Trade.Sell` is what they paid. + +```graphql +{ + EVM(network: arc_testnet) { + DEXTrades( + limit: {count: 20} + orderBy: {descending: Block_Time} + ) { + Block { + Number + Time + } + Transaction { + Hash + From + } + Trade { + Dex { + ProtocolName + SmartContract + } + Buy { + Amount + Currency { + Symbol + SmartContract + } + Price + } + Sell { + Amount + Currency { + Symbol + SmartContract + } + } + } + } + } +} +``` + +--- + +## Trades of a token + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-trades-of-a-token) + +`DEXTradeByTokens` returns one row per token side of every trade, so a token filter catches it whether it was bought or sold. `Side.Type` says which direction the trade was from the token's point of view. + +```graphql +{ + EVM(network: arc_testnet) { + DEXTradeByTokens( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + Trade: { + Currency: {SmartContract: {is: "0xe2cfd2893ad90e8a5b4f87c5cad22d150b1e12a0"}} + } + } + ) { + Block { + Time + } + Transaction { + Hash + } + Trade { + Amount + Price + Currency { + Symbol + } + Side { + Type + Amount + Currency { + Symbol + SmartContract + } + } + Dex { + ProtocolName + } + } + } + } +} +``` + +--- + +## Trades on one DEX + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-uniswap-v4-trades) + +Filter by `Dex.ProtocolName`. Values seen on Arc testnet are `uniswap_v4`, `uniswap_v3`, `uniswap_v2`, `curve_v1` and `aerodrome_v1`. + +```graphql +{ + EVM(network: arc_testnet) { + DEXTrades( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: {Trade: {Dex: {ProtocolName: {is: "uniswap_v4"}}}} + ) { + Block { + Time + } + Transaction { + Hash + } + Trade { + Dex { + ProtocolName + SmartContract + } + Buy { + Amount + Currency { + Symbol + SmartContract + } + } + Sell { + Amount + Currency { + Symbol + SmartContract + } + } + } + } + } +} +``` + +--- + +## Trades in one pool + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-trades-in-a-pool) + +For Uniswap v2 and v3 the pool has its own address in `Trade.Dex.SmartContract`. This example reads the v3 USDC/USDT pool. + +```graphql +{ + EVM(network: arc_testnet) { + DEXTrades( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + Trade: { + Dex: {SmartContract: {is: "0x715f78de0cea7428a5ede4a0c491b05e7a8caff2"}} + } + } + ) { + Block { + Time + } + Transaction { + Hash + From + } + Trade { + Buy { + Amount + Currency { + Symbol + } + Price + } + Sell { + Amount + Currency { + Symbol + } + } + } + } + } +} +``` + +--- + +## Trades of a wallet + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-trades-of-a-wallet) + +`Transaction.From` is the externally owned account that signed the swap. `Trade.Buy.Buyer` and `Trade.Sell.Seller` are the addresses that received and paid the tokens, which can be a router rather than the signer. + +```graphql +{ + EVM(network: arc_testnet) { + DEXTrades( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + Transaction: {From: {is: "0x47262d76684b071ba33304e5aa8b424035f3e06c"}} + } + ) { + Block { + Time + } + Transaction { + Hash + } + Trade { + Dex { + ProtocolName + } + Buy { + Amount + Currency { + Symbol + } + Buyer + } + Sell { + Amount + Currency { + Symbol + } + Seller + } + } + } + } +} +``` + +--- + +## OHLCV candles for a token + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-ohlcv-candles) + +Hourly candles for ARCFOMO priced in native USDC. `Block.Time(interval: ...)` buckets the trades; `open` and `close` take the price at the lowest and highest block in the bucket. Change `count` and `in` for other intervals. + +```graphql +{ + EVM(network: arc_testnet) { + DEXTradeByTokens( + limit: {count: 24} + orderBy: {descendingByField: "Block_Time"} + where: { + Trade: { + Currency: {SmartContract: {is: "0xe2cfd2893ad90e8a5b4f87c5cad22d150b1e12a0"}} + Side: { + Currency: {SmartContract: {is: "0x0000000000000000000000000000000000000000"}} + } + } + } + ) { + Block { + Time(interval: {in: hours, count: 1}) + } + volume: sum(of: Trade_Amount) + Trade { + high: Price(maximum: Trade_Price) + low: Price(minimum: Trade_Price) + open: Price(minimum: Block_Number) + close: Price(maximum: Block_Number) + } + count + } + } +} +``` + +--- + +## Latest price of a token + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-latest-token-price) + +The price of the most recent trade against native USDC. Because the quote is a dollar stablecoin, `Trade.Price` here is effectively a USD price even though `PriceInUSD` is 0 on testnet. + +```graphql +{ + EVM(network: arc_testnet) { + DEXTradeByTokens( + limit: {count: 1} + orderBy: {descending: Block_Time} + where: { + Trade: { + Currency: {SmartContract: {is: "0xe2cfd2893ad90e8a5b4f87c5cad22d150b1e12a0"}} + Side: { + Currency: {SmartContract: {is: "0x0000000000000000000000000000000000000000"}} + } + } + } + ) { + Block { + Time + } + Trade { + Price + Currency { + Symbol + } + Side { + Currency { + Symbol + } + } + Dex { + ProtocolName + } + } + } + } +} +``` + +--- + +## Most traded tokens + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-most-traded-tokens) + +Tokens ranked by trade count over the last 24 hours. Native USDC is the quote on most pools, so it tops the list; the rows under it are the tokens people actually trade. + +```graphql +{ + EVM(network: arc_testnet) { + DEXTradeByTokens( + limit: {count: 20} + orderBy: {descendingByField: "count"} + where: {Block: {Time: {since_relative: {hours_ago: 24}}}} + ) { + Trade { + Currency { + Symbol + Name + SmartContract + } + } + count + volume: sum(of: Trade_Amount) + traders: uniq(of: Transaction_From) + } + } +} +``` + +--- + +## Trade count by DEX protocol + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-trades-by-dex) + +Which DEXes carry the testnet's volume. Uniswap v4 dominates at the time of writing. + +```graphql +{ + EVM(network: arc_testnet) { + DEXTrades( + limit: {count: 10} + orderBy: {descendingByField: "count"} + where: {Block: {Time: {since_relative: {hours_ago: 24}}}} + ) { + Trade { + Dex { + ProtocolFamily + ProtocolName + } + } + count + pools: uniq(of: Trade_Dex_SmartContract) + traders: uniq(of: Transaction_From) + } + } +} +``` + +--- + +## Most active traders + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-most-active-traders) + +Signers ranked by swap count. On a testnet the top rows are usually bots and routers; drop the first few addresses to find real wallets. + +```graphql +{ + EVM(network: arc_testnet) { + DEXTrades( + limit: {count: 20} + orderBy: {descendingByField: "count"} + where: {Block: {Time: {since_relative: {hours_ago: 24}}}} + ) { + Transaction { + From + } + count + tokens: uniq(of: Trade_Buy_Currency_SmartContract) + } + } +} +``` + +--- + +## FAQ + +**Why is every `AmountInUSD` and `PriceInUSD` zero?** +Arc testnet has no token price index, so USD fields are 0 by design. `Trade.Price` is the ratio between the two sides and is correct. When the quote is USDC or another dollar stablecoin, that ratio is a dollar price. + +**Can I use `Trading.Trades` with `bid:arc_testnet`?** +No. The `Trading` cubes cover mainnet chains with USD pricing. Arc testnet is served only through `EVM(network: arc_testnet)`. + +**How far back does the data go?** +Only the `realtime` dataset exists for the testnet, and it holds a rolling window of recent blocks. Measure it with `Block { Time(minimum: Block_Time) }` rather than assuming a depth. `dataset: archive` and `dataset: combined` return errors. + +**Why does native USDC show two different contract addresses?** +The native gas token is USDC. The trade cubes report it as the zero address with name `USD Coin`; `Transfers` and `Balances` report it as `"0x"` with `Currency.Native: true`. The ERC-20 interface at `0x3600000000000000000000000000000000000000` is a separate currency with 6 decimals and name `USDC`. + +**Do Solidity selectors and topic hashes work the same as on Ethereum?** +Yes. Arc is EVM-compatible, so ABIs, 4-byte selectors and topic0 hashes carry over unchanged. diff --git a/docs/blockchain/arc-testnet/arc-testnet-transactions-api.md b/docs/blockchain/arc-testnet/arc-testnet-transactions-api.md new file mode 100644 index 00000000..cde4b6aa --- /dev/null +++ b/docs/blockchain/arc-testnet/arc-testnet-transactions-api.md @@ -0,0 +1,380 @@ +--- +title: "Arc Testnet Transactions, Blocks & Fees API" +description: "Query and stream transactions, receipts, blocks and USDC gas fees on Circle's Arc testnet with Bitquery GraphQL: transaction by hash, address history, failed transactions, block stats and fee analytics." +sidebar_position: 5 +keywords: + - Arc testnet transactions API + - Arc testnet blocks API + - Arc testnet gas fees USDC + - Arc testnet transaction by hash + - Arc testnet receipts + - Arc testnet block explorer API + - Arc testnet eth_getTransactionByHash alternative + - Circle Arc transactions API + - arc_testnet Transactions + - Bitquery Arc testnet +--- +# Arc Testnet Transactions, Blocks & Fees API + +Query and stream **transactions, receipts and blocks on Arc testnet** with Bitquery GraphQL. The `EVM.Transactions` and `EVM.Blocks` cubes on `network: arc_testnet` cover what a block explorer shows for a hash, an address or a block, with fees in **USDC** because USDC is the chain's gas token. + +Every query on this page was executed against the production endpoint before publishing. Change `query` to `subscription` on any of them to stream the same rows. + +:::warning Testnet: realtime only, USD fields are 0 +Only `dataset: realtime` exists for Arc testnet; leave the `dataset` argument out. `ValueInUSD`, `CostInUSD`, `GasPriceInUSD` and the other `...InUSD` fields return 0. Fee fields such as `Fee.SenderFee` are native USDC and populated. +::: + +:::note API Key Required +To query or stream data outside the Bitquery IDE, you need an API access token. + +Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorization/how-to-generate/) +::: + +:::tip Related docs +- [Arc Testnet API overview](/docs/blockchain/arc-testnet/) — network facts, every cube and stream in one place +- [Arc Testnet Calls API](/docs/blockchain/arc-testnet/arc-testnet-calls-api/) — the call tree inside a transaction +- [Arc Testnet Transfers API](/docs/blockchain/arc-testnet/arc-testnet-transfers-api/) +- [EVM Transactions schema](/docs/schema/evm/transactions/) +- [EVM Blocks schema](/docs/schema/evm/blocks/) +::: + +**On this page:** [Stream](#stream-transactions) · [Latest](#latest-transactions) · [By hash](#transaction-by-hash) · [By address](#transactions-of-an-address) · [Failed](#failed-transactions) · [Fees](#gas-fees-in-usdc) · [Latest blocks](#latest-blocks) · [Block by number](#block-by-number) · [Block stats](#block-and-throughput-statistics) · [FAQ](#faq) + +--- + +## Stream transactions + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-stream-transactions) + +Every transaction as blocks are indexed. Arc produces a block well under every second, so expect a steady feed. + +```graphql +subscription { + EVM(network: arc_testnet) { + Transactions { + Block { + Number + Time + } + Transaction { + Hash + From + To + Value + Gas + Type + Nonce + } + Receipt { + Status + GasUsed + ContractAddress + } + Fee { + SenderFee + EffectiveGasPrice + } + } + } +} +``` + +--- + +## Latest transactions + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-latest-transactions) + +```graphql +{ + EVM(network: arc_testnet) { + Transactions( + limit: {count: 20} + orderBy: {descending: Block_Time} + ) { + Block { + Number + Time + } + Transaction { + Hash + From + To + Value + Type + } + Receipt { + Status + GasUsed + } + Fee { + SenderFee + } + } + } +} +``` + +--- + +## Transaction by hash + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-transaction-by-hash) + +The equivalent of `eth_getTransactionByHash` plus `eth_getTransactionReceipt` in one call. The example hash is a live USDC value transfer; replace it with any recent hash. + +```graphql +{ + EVM(network: arc_testnet) { + Transactions( + where: { + Transaction: { + Hash: {is: "0x9be99a14a7db15fae9b78c68c3bfb41cfd67654a7b8cdf499f56e712d8349fe1"} + } + } + ) { + Block { + Number + Time + Hash + } + Transaction { + Hash + From + To + Value + Gas + GasPrice + GasFeeCap + GasTipCap + Nonce + Type + Index + } + Receipt { + Status + GasUsed + CumulativeGasUsed + ContractAddress + } + Fee { + SenderFee + EffectiveGasPrice + PriorityFeePerGas + Burnt + } + } + } +} +``` + +--- + +## Transactions of an address + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-transactions-of-an-address) + +Sent and received transactions of one address, newest first. This is the explorer's address page. + +```graphql +{ + EVM(network: arc_testnet) { + Transactions( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + any: [ + {Transaction: {From: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}}} + {Transaction: {To: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}}} + ] + } + ) { + Block { + Number + Time + } + Transaction { + Hash + From + To + Value + } + Receipt { + Status + } + Fee { + SenderFee + } + } + } +} +``` + +--- + +## Failed transactions + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-failed-transactions) + +Transactions whose receipt status is 0. Join the [reverted calls](/docs/blockchain/arc-testnet/arc-testnet-calls-api/#reverted-calls) query on the hash to see the revert reason. + +```graphql +{ + EVM(network: arc_testnet) { + Transactions( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: {TransactionStatus: {Success: false}} + ) { + Block { + Time + } + Transaction { + Hash + From + To + Gas + } + Receipt { + GasUsed + } + Fee { + SenderFee + } + } + } +} +``` + +--- + +## Gas fees in USDC + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-gas-fee-statistics) + +Because gas is paid in USDC, `Fee.SenderFee` is already a dollar amount. This gives the average, median and total fee per hour along with the average effective gas price. + +```graphql +{ + EVM(network: arc_testnet) { + Transactions( + orderBy: {descendingByField: "Block_Time"} + limit: {count: 24} + ) { + Block { + Time(interval: {in: hours, count: 1}) + } + count + totalFees: sum(of: Fee_SenderFee) + avgFee: average(of: Fee_SenderFee) + medianFee: median(of: Fee_SenderFee) + avgGasPrice: average(of: Fee_EffectiveGasPrice) + avgGasUsed: average(of: Receipt_GasUsed) + } + } +} +``` + +--- + +## Latest blocks + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-latest-blocks) + +```graphql +{ + EVM(network: arc_testnet) { + Blocks( + limit: {count: 20} + orderBy: {descending: Block_Number} + ) { + Block { + Number + Time + Hash + TxCount + GasUsed + GasLimit + BaseFee + Coinbase + } + } + } +} +``` + +Change `query` to `subscription` and drop `limit` and `orderBy` to receive each block header as it is indexed. + +--- + +## Block by number + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-block-by-number) + +```graphql +{ + EVM(network: arc_testnet) { + Blocks(where: {Block: {Number: {eq: "61696399"}}}) { + Block { + Number + Time + Hash + ParentHash + TxCount + GasUsed + GasLimit + BaseFee + Coinbase + Difficulty + } + } + } +} +``` + +--- + +## Block and throughput statistics + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-block-statistics) + +Blocks, transactions, average transactions per block and average gas per block for each of the last 24 hours. Divide the block count by 3600 to get blocks per second. + +```graphql +{ + EVM(network: arc_testnet) { + Blocks( + orderBy: {descendingByField: "Block_Time"} + limit: {count: 24} + ) { + Block { + Time(interval: {in: hours, count: 1}) + } + blocks: count + transactions: sum(of: Block_TxCount) + avgTxPerBlock: average(of: Block_TxCount) + avgGasUsed: average(of: Block_GasUsed) + medianGasUsed: median(of: Block_GasUsed) + } + } +} +``` + +--- + +## FAQ + +**What unit is `Fee.SenderFee` in?** +Native USDC. Arc pays gas in USDC, so a fee of `0.0025` is a quarter of a cent. `CostInUSD` and `GasPriceInUSD` are still 0 on testnet because there is no price index, even though the native unit is a dollar. + +**Why is `Transaction.GasPrice` 0 while the fee is not?** +Arc transactions are EIP-1559 type 2. Read `Fee.EffectiveGasPrice`, `Transaction.GasFeeCap` and `Transaction.GasTipCap`; the legacy `GasPrice` field is 0 for these. + +**How fast are blocks?** +Well under a second on average. Measure the current rate with the [block statistics](#block-and-throughput-statistics) query rather than assuming a fixed interval. + +**Can I get a transaction's internal calls and logs from here?** +Use the same hash on the [Calls API](/docs/blockchain/arc-testnet/arc-testnet-calls-api/#internal-calls-of-a-transaction) for the call tree and the [Events API](/docs/blockchain/arc-testnet/arc-testnet-events-api/) for the logs. + +**Is there a block explorer?** +Circle's testnet explorer is at [testnet.arcscan.app](https://testnet.arcscan.app). Bitquery is an indexed data API rather than an explorer, and every explorer lookup on this page can be run in bulk or streamed. diff --git a/docs/blockchain/arc-testnet/arc-testnet-transfers-api.md b/docs/blockchain/arc-testnet/arc-testnet-transfers-api.md new file mode 100644 index 00000000..16c6f42f --- /dev/null +++ b/docs/blockchain/arc-testnet/arc-testnet-transfers-api.md @@ -0,0 +1,479 @@ +--- +title: "Arc Testnet Transfers API & Streams" +description: "Query and stream token transfers on Circle's Arc testnet with Bitquery GraphQL: native USDC, ERC-20 USDC, EURC, wallet ledgers, large transfers, most-transferred tokens and daily volume." +sidebar_position: 2 +keywords: + - Arc testnet transfers API + - Arc testnet USDC transfers + - Arc testnet EURC transfers + - Arc testnet token transfers + - Arc testnet wallet transfers + - Circle Arc transfers API + - arc_testnet Transfers + - stream Arc testnet transfers + - Bitquery Arc testnet +--- +# Arc Testnet Transfers API & Streams + +Query and stream **token transfers on Arc testnet** with Bitquery GraphQL. This is the shared **EVM `Transfers`** cube scoped to `network: arc_testnet`, so a query written for Ethereum or Base runs here by changing the network name. + +Arc's native gas token is **USDC**, and the chain carries an ERC-20 USDC interface, **EURC**, a testnet **USDT** and thousands of test tokens. Every query on this page was executed against the production endpoint before publishing. Change `query` to `subscription` on any of them to stream the same rows over WebSocket. + +:::warning Testnet: USD fields are 0 and only the realtime dataset exists +`Transfer.AmountInUSD` is always **0** on Arc testnet. Filter and rank by `Transfer.Amount` instead. Leave the `dataset` argument out; `archive` and `combined` return errors on the testnet. +::: + +:::note API Key Required +To query or stream data outside the Bitquery IDE, you need an API access token. + +Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorization/how-to-generate/) +::: + +:::tip Related docs +- [Arc Testnet API overview](/docs/blockchain/arc-testnet/) — network facts, every cube and stream in one place +- [Arc Testnet DEX Trades API](/docs/blockchain/arc-testnet/arc-testnet-trades-api/) +- [Arc Testnet Balances API](/docs/blockchain/arc-testnet/arc-testnet-balances-api/) +- [Arc Testnet Events API](/docs/blockchain/arc-testnet/arc-testnet-events-api/) +- [Transfers vs Events vs Calls](/docs/start/mental-model-transfers-events-calls/) +- [EVM Transfers schema](/docs/schema/evm/transfers/) +::: + +**On this page:** [Currencies](#how-usdc-appears-in-transfers) · [Stream](#stream-real-time-transfers) · [Latest](#latest-transfers) · [Native USDC](#native-usdc-transfers) · [By token](#transfers-of-a-token) · [By address](#transfers-of-an-address) · [Between two addresses](#transfers-between-two-addresses) · [Large transfers](#large-transfers) · [Top tokens](#most-transferred-tokens) · [Hourly volume](#hourly-transfer-volume-of-a-token) · [FAQ](#faq) + +--- + +## How USDC appears in Transfers + +USDC exists in three forms on Arc testnet. Check which one a row is before you sum or rank anything. + +| Currency | `SmartContract` | `Native` | Decimals | What it is | +| --- | --- | --- | --- | --- | +| USDC (native) | `0x` | `true` | 18 | The gas token. Value transfers and gas fees. | +| USDC (ERC-20) | `0x3600000000000000000000000000000000000000` | `false` | 6 | The ERC-20 interface most contracts and wallets call. Symbol `USDC`, name `USDC`. | +| System ledger | `0xfffffffffffffffffffffffffffffffffffffffe` | `false` | 0 | A system address that emits a raw `Transfer` event mirroring native USDC movements as 18-decimal integers with no symbol. Exclude it from token rankings. | + +Other stablecoins seen on the testnet: + +| Token | Address | Decimals | +| --- | --- | --- | +| EURC | `0x89b50855aa3be2f677cd6303cec089b5f319d72a` | 6 | +| USDT (testnet mock) | `0x175cdb1d338945f0d851a741ccf787d343e57952` | 18 | +| WUSDC (Wrapped USDC) | `0x911b4000d3422f482f4062a913885f7b035382df` | 18 | + +--- + +## Stream real-time transfers + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-stream-transfers) + +Every transfer on the network as it is indexed. Filter inside `where` to narrow the socket to a token, an address or a size floor. + +```graphql +subscription { + EVM(network: arc_testnet) { + Transfers { + Block { + Number + Time + } + Transaction { + Hash + From + To + } + Transfer { + Amount + Sender + Receiver + Type + Currency { + Name + Symbol + SmartContract + Native + Decimals + } + } + } + } +} +``` + +--- + +## Latest transfers + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-latest-transfers) + +```graphql +{ + EVM(network: arc_testnet) { + Transfers( + limit: {count: 20} + orderBy: {descending: Block_Time} + ) { + Block { + Number + Time + } + Transaction { + Hash + } + Transfer { + Amount + Sender + Receiver + Currency { + Symbol + SmartContract + Native + } + } + } + } +} +``` + +--- + +## Native USDC transfers + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-native-usdc-transfers) + +`Currency: {Native: true}` selects value transfers of the gas token. The floor of 100 USDC keeps dust and fee movements out. + +```graphql +{ + EVM(network: arc_testnet) { + Transfers( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + Transfer: { + Currency: {Native: true} + Amount: {gt: "100"} + } + } + ) { + Block { + Time + } + Transaction { + Hash + } + Transfer { + Amount + Sender + Receiver + Currency { + Symbol + Native + } + } + } + } +} +``` + +--- + +## Transfers of a token + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-erc20-usdc-transfers) + +Filter on the token contract. This example reads the ERC-20 USDC interface; swap in EURC or any test token. + +```graphql +{ + EVM(network: arc_testnet) { + Transfers( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + Transfer: { + Currency: {SmartContract: {is: "0x3600000000000000000000000000000000000000"}} + } + } + ) { + Block { + Time + } + Transaction { + Hash + } + Transfer { + Amount + Sender + Receiver + Currency { + Symbol + Decimals + } + } + } + } +} +``` + +--- + +## Transfers of an address + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-transfers-of-an-address) + +Incoming and outgoing transfers in one list. Replace the address with any wallet or contract. + +```graphql +{ + EVM(network: arc_testnet) { + Transfers( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + any: [ + {Transfer: {Sender: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}}} + {Transfer: {Receiver: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}}} + ] + } + ) { + Block { + Time + } + Transaction { + Hash + } + Transfer { + Amount + Sender + Receiver + Currency { + Symbol + SmartContract + Native + } + } + } + } +} +``` + +### Sent and received totals per token + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-address-sent-received) + +Two aliased selections give the outbound and inbound sums per currency for a wallet. + +```graphql +{ + EVM(network: arc_testnet) { + sent: Transfers( + where: {Transfer: {Sender: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}}} + orderBy: {descendingByField: "amount"} + limit: {count: 10} + ) { + Transfer { + Currency { + Symbol + SmartContract + } + } + amount: sum(of: Transfer_Amount) + count + } + received: Transfers( + where: {Transfer: {Receiver: {is: "0x2de8906a641d65d490bc60a4179d961d59742bcb"}}} + orderBy: {descendingByField: "amount"} + limit: {count: 10} + ) { + Transfer { + Currency { + Symbol + SmartContract + } + } + amount: sum(of: Transfer_Amount) + count + } + } +} +``` + +--- + +## Transfers between two addresses + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-transfers-between-addresses) + +Flows from one address to another, in either direction. Useful for tracing a faucet, a bridge or a counterparty. + +```graphql +{ + EVM(network: arc_testnet) { + Transfers( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + any: [ + { + Transfer: { + Sender: {is: "0xe72f8175ab0991dbb778f6de62009c5bf97c17f7"} + Receiver: {is: "0x1d70945634f618eefdf9edaadb59b9a183cef929"} + } + } + { + Transfer: { + Sender: {is: "0x1d70945634f618eefdf9edaadb59b9a183cef929"} + Receiver: {is: "0xe72f8175ab0991dbb778f6de62009c5bf97c17f7"} + } + } + ] + } + ) { + Block { + Time + } + Transaction { + Hash + } + Transfer { + Amount + Sender + Receiver + Currency { + Symbol + Native + } + } + } + } +} +``` + +--- + +## Large transfers + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-large-usdc-transfers) + +With USD values at 0 on testnet, size filters go on `Transfer.Amount` for one currency at a time. This catches ERC-20 USDC moves above 10,000. + +```graphql +{ + EVM(network: arc_testnet) { + Transfers( + limit: {count: 20} + orderBy: {descending: Transfer_Amount} + where: { + Block: {Time: {since_relative: {hours_ago: 24}}} + Transfer: { + Currency: {SmartContract: {is: "0x3600000000000000000000000000000000000000"}} + Amount: {gt: "10000"} + } + } + ) { + Block { + Time + } + Transaction { + Hash + } + Transfer { + Amount + Sender + Receiver + Currency { + Symbol + } + } + } + } +} +``` + +--- + +## Most transferred tokens + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-most-transferred-tokens) + +Tokens ranked by transfer count over 24 hours, with distinct senders and receivers. The system ledger address is excluded. + +```graphql +{ + EVM(network: arc_testnet) { + Transfers( + limit: {count: 20} + orderBy: {descendingByField: "count"} + where: { + Block: {Time: {since_relative: {hours_ago: 24}}} + Transfer: { + Currency: {SmartContract: {not: "0xfffffffffffffffffffffffffffffffffffffffe"}} + } + } + ) { + Transfer { + Currency { + Symbol + Name + SmartContract + Native + } + } + count + amount: sum(of: Transfer_Amount) + senders: uniq(of: Transfer_Sender) + receivers: uniq(of: Transfer_Receiver) + } + } +} +``` + +--- + +## Hourly transfer volume of a token + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-hourly-transfer-volume) + +Transfer volume of ERC-20 USDC bucketed by hour, for charts and alerts. + +```graphql +{ + EVM(network: arc_testnet) { + Transfers( + orderBy: {descendingByField: "Block_Time"} + limit: {count: 24} + where: { + Transfer: { + Currency: {SmartContract: {is: "0x3600000000000000000000000000000000000000"}} + } + } + ) { + Block { + Time(interval: {in: hours, count: 1}) + } + amount: sum(of: Transfer_Amount) + count + senders: uniq(of: Transfer_Sender) + } + } +} +``` + +--- + +## FAQ + +**Why does `AmountInUSD` return 0?** +Arc testnet has no token price index, so every USD field is 0. Rank and filter by `Transfer.Amount`, one currency at a time. + +**Which USDC address should I filter on?** +For gas-token value transfers use `Currency: {Native: true}`. For the ERC-20 interface that wallets and contracts call, use `0x3600000000000000000000000000000000000000`. Do not filter on `0xfffffffffffffffffffffffffffffffffffffffe`; it is a system ledger that duplicates native movements as raw integers. + +**Why are native amounts 18 decimals when USDC has 6?** +The EVM represents the gas token in wei-style 18-decimal units regardless of what the token is called. Bitquery applies those 18 decimals to native rows and the contract's own 6 decimals to ERC-20 rows, so `Amount` is a whole-token value in both cases. + +**Can I read history older than the realtime window?** +Not on the testnet. Only `dataset: realtime` exists; `archive` and `combined` return errors. Check the window with `Block { Time(minimum: Block_Time) }`. + +**How do I stream transfers for one wallet?** +Take the [transfers of an address](#transfers-of-an-address) query, change `query` to `subscription` and drop `limit` and `orderBy`. diff --git a/docs/blockchain/arc-testnet/index.md b/docs/blockchain/arc-testnet/index.md new file mode 100644 index 00000000..ccc536de --- /dev/null +++ b/docs/blockchain/arc-testnet/index.md @@ -0,0 +1,215 @@ +--- +title: "Arc Testnet API: Circle's Stablecoin L1 via GraphQL, WebSocket and Kafka" +description: "Arc testnet API (chain ID 5042002): trades, transfers, balances, events, calls, transactions and blocks on Circle's USDC-gas Layer 1 via Bitquery GraphQL, WebSocket streams and Kafka topics." +sidebar_position: 0 +keywords: + - Arc testnet API + - Arc blockchain API + - Circle Arc API + - Arc network data API + - Arc testnet GraphQL + - Arc testnet WebSocket + - Arc testnet Kafka + - Arc testnet chain ID 5042002 + - Arc USDC gas token + - Arc stablecoin blockchain + - Arc testnet explorer API + - Arc testnet Uniswap v4 + - arc_testnet + - arc-testnet Kafka topics + - Bitquery Arc API +--- + +import FAQ from "@site/src/components/FAQ"; + +# Arc Testnet API: Circle's Stablecoin L1 via GraphQL, WebSocket and Kafka + +**Arc** is Circle's EVM-compatible Layer 1 built for stablecoin finance: **USDC is the native gas token**, blocks finalize in well under a second on the Malachite BFT consensus, and the chain carries USDC, EURC and a growing set of DeFi deployments led by Uniswap v4. Bitquery indexes the **Arc testnet** as `EVM(network: arc_testnet)` and publishes it as Kafka topics under `arc-testnet.*`, so you can build and test against the chain before mainnet with the same queries you already use on Ethereum, Base or Robinhood Chain. + +This page is the map. Use it to pick the cube that answers your question, then jump to the linked guide. + +:::note API Key Required +To query or stream data outside the Bitquery IDE, you need an API access token. + +Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorization/how-to-generate/) +::: + +--- + +## Arc testnet at a glance {#network-facts} + +| Property | Value | +| --- | --- | +| Bitquery network name | `arc_testnet` in `EVM(network: arc_testnet)` | +| Kafka topic prefix | `arc-testnet.` | +| Chain ID | `5042002` | +| Stack | EVM, Circle Arc Layer 1, Malachite BFT consensus | +| Gas token | USDC, tracked as `Currency.Native: true` | +| USDC (ERC-20 interface, 6 decimals) | `0x3600000000000000000000000000000000000000` | +| EURC (6 decimals) | `0x89b50855aa3be2f677cd6303cec089b5f319d72a` | +| Uniswap v4 PoolManager | `0x1d70945634f618eefdf9edaadb59b9a183cef929` | +| Public explorer | [testnet.arcscan.app](https://testnet.arcscan.app). Bitquery is an indexed data API, not an explorer or an RPC node | +| GraphQL endpoint | `https://streaming.bitquery.io/graphql` for queries and subscriptions | + +--- + +## What is different on a testnet {#testnet-limits} + +Arc testnet is indexed with the same EVM schema as every other chain, with four differences you should know before writing queries. + +| Difference | What it means for your query | +| --- | --- | +| **USD values are 0** | Every `...InUSD` field (`AmountInUSD`, `PriceInUSD`, `ValueInUSD`, `CostInUSD`) returns 0. There is no token price index on a testnet. Native prices such as `Trade.Price` work, and since most pairs quote in USDC they are effectively dollar prices. | +| **Realtime dataset only** | There is no archive for the testnet. Leave the `dataset` argument out; `archive` and `combined` return errors. The realtime window is a rolling range of recent blocks; measure it with `Block { Time(minimum: Block_Time) }`. | +| **No `Trading` cubes** | `Trading.Trades`, `Tokens` and `Pairs` cover mainnet chains with USD pricing. Use the chain-level `DEXTrades` and `DEXTradeByTokens` cubes. | +| **Some cubes are unavailable** | `Holders` needs the archive and is not served. `DEXPoolEvents` and `DEXPoolSlippages` have no data yet. `Balances`, `BalanceUpdates` and `TransactionBalances` work. | + +Arc **mainnet** will be indexed with USD pricing from the token price index and an archive dataset. + +--- + +## Quick start: stream every swap on Arc testnet {#quick-start} + +Paste this into the [Bitquery IDE](https://ide.bitquery.io) to watch the network trade in real time. Uniswap v4 carries most of the volume, with v3, v2, Curve and Aerodrome deployments behind it. + +▶️ [Run in IDE](https://ide.bitquery.io/arc-testnet-stream-dex-trades) + +```graphql +subscription { + EVM(network: arc_testnet) { + DEXTrades { + Block { + Number + Time + } + Transaction { + Hash + From + } + Trade { + Dex { + ProtocolFamily + ProtocolName + SmartContract + } + Buy { + Amount + Buyer + Seller + Price + Currency { + Name + Symbol + SmartContract + } + } + Sell { + Amount + Buyer + Seller + Price + Currency { + Name + Symbol + SmartContract + } + } + } + } + } +} +``` + +Change `subscription` to `query`, add `limit: {count: 10}` and `orderBy: {descending: Block_Time}`, and the same selection set returns the latest trades instead. OHLCV candles, token prices, top tokens and trader activity are on the [Arc Testnet DEX Trades API](/docs/blockchain/arc-testnet/arc-testnet-trades-api) page. + +--- + +## Pick the right API {#pick-the-right-api} + +| What you want | Use this | Guide | +| --- | --- | --- | +| Live swaps, OHLCV, token prices, top tokens, DEX breakdown, trader activity | `DEXTrades`, `DEXTradeByTokens` | [Arc Testnet DEX Trades API](/docs/blockchain/arc-testnet/arc-testnet-trades-api) | +| Who sent what to whom, wallet ledgers, large transfers, most-transferred tokens | `Transfers` | [Arc Testnet Transfers API](/docs/blockchain/arc-testnet/arc-testnet-transfers-api) | +| Any decoded contract event, new Uniswap v4/v3/v2 pools, an `eth_getLogs` replacement | `Events` | [Arc Testnet Events API](/docs/blockchain/arc-testnet/arc-testnet-events-api) | +| Method calls, internal traces, contract deployments, reverts | `Calls` | [Arc Testnet Calls & Traces API](/docs/blockchain/arc-testnet/arc-testnet-calls-api) | +| Transactions, receipts, blocks, USDC gas fees | `Transactions`, `Blocks` | [Arc Testnet Transactions, Blocks & Fees API](/docs/blockchain/arc-testnet/arc-testnet-transactions-api) | +| A wallet's portfolio, balance history, active holders, token total supply | `Balances`, `BalanceUpdates`, `TransactionBalances` | [Arc Testnet Balances & Token Supply API](/docs/blockchain/arc-testnet/arc-testnet-balances-api) | + +--- + +## USDC on Arc: native and ERC-20 {#usdc} + +USDC is both the gas token and an ERC-20 on Arc, and Bitquery tracks the two as separate currencies. + +| Form | How it appears | Decimals | +| --- | --- | --- | +| Native USDC | `Currency.Native: true` with `SmartContract: "0x"` in `Transfers` and `Balances`; the zero address with name `USD Coin` in `DEXTrades` and `DEXTradeByTokens` | 18 | +| ERC-20 USDC | `SmartContract: "0x3600000000000000000000000000000000000000"`, symbol `USDC` | 6 | +| System ledger | `0xfffffffffffffffffffffffffffffffffffffffe`, no symbol, raw 18-decimal integers mirroring native movements | 0 | + +Filter on `Native: true` for gas-token value transfers and on the `0x3600...` contract for the ERC-20 interface. Exclude the system ledger from token rankings. Transaction fees are in native USDC, so `Fee.SenderFee` on the [Transactions API](/docs/blockchain/arc-testnet/arc-testnet-transactions-api#gas-fees-in-usdc) is already a dollar figure. + +--- + +## DEXes on Arc testnet {#dexes} + +| Protocol | `Dex.ProtocolName` | Notes | +| --- | --- | --- | +| Uniswap v4 | `uniswap_v4` | Most swaps on the testnet. Pools live in the PoolManager singleton, so `Dex.SmartContract` is `0x1d70945634f618eefdf9edaadb59b9a183cef929` and new pools are `Initialize` events. | +| Uniswap v3 | `uniswap_v3` | Several factory deployments; `Dex.SmartContract` is the pool. | +| Uniswap v2 | `uniswap_v2` | Several factory deployments; `Dex.SmartContract` is the pair. | +| Curve | `curve_v1` | Stablecoin pools. | +| Aerodrome | `aerodrome_v1` | Light activity. | + +The [DEX Trades API](/docs/blockchain/arc-testnet/arc-testnet-trades-api#trade-count-by-dex-protocol) has a live breakdown by protocol, and the [Events API](/docs/blockchain/arc-testnet/arc-testnet-events-api#new-uniswap-v4-pools) streams new pools as they are created. + +--- + +## Real-time streams: WebSocket and Kafka {#streaming} + +- **WebSocket.** Every query on every page above runs as a subscription: swap `query` for `subscription` and keep the same selection set. See [WebSocket subscriptions](/docs/subscriptions/websockets/) and [authorizing a WebSocket connection](/docs/authorization/websocket/). +- **Kafka.** For firehose-scale workloads, Arc testnet is published as protobuf topics under the `arc-testnet.` prefix: `arc-testnet.transactions.proto` (transactions, calls, events), `arc-testnet.tokens.proto` (transfers, balances), `arc-testnet.dextrades.proto` (DEX trades) and `arc-testnet.raw.proto` (raw blocks). The message schemas are the same as every other EVM chain; USD fields in the messages are 0 on the testnet. See [Kafka streaming concepts](/docs/streams/kafka-streaming-concepts/) and the [EVM protobuf streams](/docs/streams/protobuf/chains/EVM-protobuf/). + +--- + +## Datasets and history {#datasets} + +Only the **`realtime`** dataset exists for Arc testnet. It holds a rolling window of recent blocks, and its depth is not fixed, so measure it before relying on a time range: + +```graphql +{ + EVM(network: arc_testnet) { + Blocks { + count + earliest: Block { + Time(minimum: Block_Time) + } + latest: Block { + Time(maximum: Block_Time) + } + } + } +} +``` + +`dataset: archive` and `dataset: combined` return errors on the testnet. The archive dataset, and with it the `Holders` cube and long time ranges, will be available for Arc mainnet. + +--- + +{"Arc is Circle's EVM-compatible Layer 1 for stablecoin finance, with USDC as the native gas token and sub-second finality on the Malachite BFT consensus. The testnet chain ID is "}{"5042002"}{". In Bitquery it is "}{"EVM(network: arc_testnet)"}{". Solidity ABIs, topic0 hashes and 4-byte selectors work exactly as they do on Ethereum."}

}, + { q: "Why are all USD values zero?", id: "why-are-all-usd-values-zero", a: "There is no token price index for a testnet, so every ...InUSD field is 0. Native prices such as Trade.Price are correct, and because most pairs quote in USDC they are effectively dollar prices. Arc mainnet will carry USD values from the price index.", + answer:

{"There is no token price index for a testnet, so every "}{"...InUSD"}{" field is 0. Native prices such as "}{"Trade.Price"}{" are correct, and because most pairs quote in USDC they are effectively dollar prices. Arc mainnet will carry USD values from the price index."}

}, + { q: "How far back does Arc testnet data go?", id: "how-far-back-does-arc-testnet-data-go", a: "Only the realtime dataset exists, holding a rolling window of recent blocks. There is no archive for the testnet, so dataset: archive and dataset: combined return errors. Measure the window with a Block Time(minimum) query before assuming a range.", + answer:

{"Only the "}{"realtime"}{" dataset exists, holding a rolling window of recent blocks. There is no archive for the testnet, so "}{"dataset: archive"}{" and "}{"dataset: combined"}{" return errors. Measure the window with the "}{"dataset probe"}{" before assuming a range."}

}, + { q: "Can I use the Trading cubes or the Holders cube on Arc testnet?", id: "can-i-use-the-trading-cubes-or-the-holders-cube-on-arc-testnet", a: "No. The Trading cubes cover mainnet chains with USD pricing, and Holders is served from the archive dataset. Use DEXTrades and DEXTradeByTokens for trades, and Balances grouped by address for holder rankings.", + answer:

{"No. The "}{"Trading"}{" cubes cover mainnet chains with USD pricing, and "}{"Holders"}{" is served from the archive dataset. Use "}{"DEXTrades"}{" and "}{"DEXTradeByTokens"}{" for trades, and "}{"BalanceUpdates summed per address"}{" for holder rankings."}

}, + { q: "Are there Kafka topics for Arc testnet?", id: "are-there-kafka-topics-for-arc-testnet", a: "Yes. Topics are published under the arc-testnet. prefix (transactions, tokens, dextrades and raw) with the same protobuf schema as other EVM chains. USD fields in the messages are 0 on the testnet.", + answer:

{"Yes. Topics are published under the "}{"arc-testnet."}{" prefix (transactions, tokens, dextrades and raw) with the same protobuf schema as other EVM chains. USD fields in the messages are 0 on the testnet. See the "}{"streams section"}{"."}

}, + { q: "Does Bitquery provide an Arc RPC endpoint, faucet or block explorer?", id: "does-bitquery-provide-an-arc-rpc-endpoint-faucet-or-block-explorer", a: "No. Bitquery is an indexed data API. Circle's testnet explorer is testnet.arcscan.app and test USDC comes from Circle's faucet. Every explorer lookup has an API equivalent here that can be queried in bulk and streamed.", + answer:

{"No. Bitquery is an indexed data API. Circle's testnet explorer is "}{"testnet.arcscan.app"}{" and test USDC comes from Circle's faucet. Every explorer lookup has an API equivalent here that can be queried in bulk and streamed: address history ("}{"Transfers"}{", "}{"Balances"}{"), transaction receipts ("}{"Transactions"}{"), contract logs ("}{"Events"}{") and internal traces ("}{"Calls"}{")."}

}, + ]} +/> diff --git a/docs/blockchain/introduction.md b/docs/blockchain/introduction.md index 7bb4af99..9ed852c2 100644 --- a/docs/blockchain/introduction.md +++ b/docs/blockchain/introduction.md @@ -37,6 +37,7 @@ Our V2 API version with enhanced features and real-time streaming: - **[Optimism](/docs/blockchain/Optimism/)** - **[opBNB](/docs/blockchain/supported-chains/)** (IDE / limited docs) - **[Robinhood](/docs/blockchain/robinhood/)** +- **[Arc Testnet](/docs/blockchain/arc-testnet/)** (Circle Arc, testnet; realtime dataset only) **Non-EVM Chains:** - **[Solana](/docs/blockchain/Solana/)** diff --git a/docs/blockchain/supported-chains.mdx b/docs/blockchain/supported-chains.mdx index 0caa2baf..c28dff6a 100644 --- a/docs/blockchain/supported-chains.mdx +++ b/docs/blockchain/supported-chains.mdx @@ -77,6 +77,7 @@ This guide lists **which blockchains Bitquery indexes** and how that lines up wi | Optimism | — | ✓ | ✓ | ✓ | ✓ | | Base | — | ✓ | ✓ | ✓ | ✓ | | Robinhood | — | ✓ | ✓ | ✓ | ✓ | +| Arc Testnet | — | ✓ | ✓ | — | — | :::note More networks @@ -100,7 +101,7 @@ This guide lists **which blockchains Bitquery indexes** and how that lines up wi | Product | Get started | |--------|-------------| -| **V2** | [Bitquery platform](https://bitquery.io/) · [Data streams](https://bitquery.io/products/data-streams) · [WebSocket streams](https://bitquery.io/products/websocket-streams) · Docs: [Intro](/docs/intro/) · Chains: [Ethereum](https://bitquery.io/blockchains/ethereum-blockchain-api), [BNB Chain](/docs/blockchain/BSC/), [Arbitrum](https://bitquery.io/blockchains/arbitrum-blockchain-api), [Optimism](https://bitquery.io/blockchains/optimism-blockchain-api), [Base](https://bitquery.io/blockchains/base-blockchain-api), [Polygon](https://bitquery.io/blockchains/polygon-blockchain-api), [Solana](https://bitquery.io/blockchains/solana-blockchain-api), [Tron](https://bitquery.io/blockchains/tron-blockchain-api), [Robinhood](/docs/blockchain/robinhood/) | +| **V2** | [Bitquery platform](https://bitquery.io/) · [Data streams](https://bitquery.io/products/data-streams) · [WebSocket streams](https://bitquery.io/products/websocket-streams) · Docs: [Intro](/docs/intro/) · Chains: [Ethereum](https://bitquery.io/blockchains/ethereum-blockchain-api), [BNB Chain](/docs/blockchain/BSC/), [Arbitrum](https://bitquery.io/blockchains/arbitrum-blockchain-api), [Optimism](https://bitquery.io/blockchains/optimism-blockchain-api), [Base](https://bitquery.io/blockchains/base-blockchain-api), [Polygon](https://bitquery.io/blockchains/polygon-blockchain-api), [Solana](https://bitquery.io/blockchains/solana-blockchain-api), [Tron](https://bitquery.io/blockchains/tron-blockchain-api), [Robinhood](/docs/blockchain/robinhood/), [Arc Testnet](/docs/blockchain/arc-testnet/) | | **V1** | [Bitquery platform](https://bitquery.io/) · [V1 documentation](https://docs.bitquery.io/v1/) · [V1 vs V2 (IDE & schema)](https://docs.bitquery.io/v1/docs/graphql-ide/v1-and-v2) | | **Kafka** | [Kafka streams](https://bitquery.io/products/kafka-streams) · [Real-time streaming hub](https://bitquery.io/products/streaming) · Docs: [Streams overview](/docs/streams/) · [Kafka concepts](/docs/streams/kafka-streaming-concepts/) | | **Cloud** | [Streaming & datashares](https://bitquery.io/products/streaming) · Docs: [Cloud data](/docs/cloud/) · [EVM](/docs/cloud/evm/) · [Solana](/docs/cloud/solana/) · [Bitcoin](/docs/cloud/bitcoin/) · [Tron](/docs/cloud/tron/) | diff --git a/docs/cubes/evm-cubes.md b/docs/cubes/evm-cubes.md index 03b30a17..2411c903 100644 --- a/docs/cubes/evm-cubes.md +++ b/docs/cubes/evm-cubes.md @@ -35,7 +35,7 @@ Every EVM chain Bitquery indexes is queried through one root, `EVM(network: ...) ## Networks -`eth`, `bsc`, `base`, `arbitrum`, `optimism`, `matic` and `robinhood` work in `EVM(network: ...)`. The chain hubs under [Blockchain](/docs/blockchain/Ethereum/) carry worked examples per chain; the schema is the same. +`eth`, `bsc`, `base`, `arbitrum`, `optimism`, `matic`, `robinhood` and `arc_testnet` work in `EVM(network: ...)`. Arc testnet is realtime-only with USD fields at 0; see the [Arc Testnet hub](/docs/blockchain/arc-testnet/). The chain hubs under [Blockchain](/docs/blockchain/Ethereum/) carry worked examples per chain; the schema is the same. ## Datasets and depth diff --git a/docs/graphql/data-coverage-retention.mdx b/docs/graphql/data-coverage-retention.mdx index 87cd4659..7c14bbf1 100644 --- a/docs/graphql/data-coverage-retention.mdx +++ b/docs/graphql/data-coverage-retention.mdx @@ -114,6 +114,15 @@ That pair is the exception, not a general rule: **every other Solana realtime cu | Trades | Since the chain was onboarded | Full history from onboarding forward. | | Transfers | Complete history | Full transfer history available. | +### Arc testnet + +Circle's Arc testnet (`EVM(network: arc_testnet)`) is served from the **realtime dataset only**. There is no archive for the testnet, so `dataset: archive` and `dataset: combined` return errors, the `Holders` cube is not available, and every `...InUSD` field is 0. The realtime window is a rolling range of recent blocks; measure it with `Block { Time(minimum: Block_Time) }`. Arc mainnet will carry an archive dataset and USD pricing. See the [Arc Testnet hub](/docs/blockchain/arc-testnet/). + +| Cube | Window | Notes | +|---|---|---| +| `DEXTrades`, `DEXTradeByTokens`, `Transfers`, `Events`, `Calls`, `Transactions`, `Blocks`, `Balances`, `BalanceUpdates`, `TransactionBalances` | Realtime window only | No archive; USD fields are 0. | +| `Holders`, `DEXPoolEvents`, `DEXPoolSlippages`, `Trading.*` | Not available | `Holders` needs the archive; pool cubes have no data yet; the Trading cubes cover mainnet chains only. | + ### Hyperliquid Hyperliquid core is an L1 order-book exchange, so its cubes carry exchange events rather than EVM blocks. All `Hyperliquid` cubes share one window. diff --git a/docs/start/endpoints.md b/docs/start/endpoints.md index 0d6ba433..8f682e8b 100644 --- a/docs/start/endpoints.md +++ b/docs/start/endpoints.md @@ -45,6 +45,7 @@ The following chains are available via the Europe regional endpoint: | Tron | `https://streaming.bitquery.io/graphql` | | Matic (Polygon) | `https://streaming.bitquery.io/graphql` | | Robinhood | `https://streaming.bitquery.io/graphql` | +| Arc Testnet | `https://streaming.bitquery.io/graphql` | ## Asia diff --git a/docs/streams/index.md b/docs/streams/index.md index 5d60d81b..9d53dee7 100644 --- a/docs/streams/index.md +++ b/docs/streams/index.md @@ -124,6 +124,7 @@ Our newest **ultra-low latency streaming technology** provides the fastest **Sol - **[Ethereum](/docs/blockchain/Ethereum/)** & Layer 2s ([Arbitrum](/docs/blockchain/Arbitrum/), [Optimism](/docs/blockchain/Optimism/), [Base](/docs/blockchain/Base/), [Polygon](/docs/blockchain/Matic/)) - **[Binance Smart Chain (BSC)](/docs/blockchain/BSC/)** - **[Robinhood](/docs/blockchain/robinhood/)** +- **[Arc Testnet](/docs/blockchain/arc-testnet/)** - **[Solana](/docs/blockchain/Solana/)** - **[TRON](/docs/blockchain/Tron/)** - **[TON](/docs/blockchain/supported-chains/)** (limited support; see coverage matrix) diff --git a/docs/streams/kafka-streaming-concepts.md b/docs/streams/kafka-streaming-concepts.md index a5e70242..9342bb25 100644 --- a/docs/streams/kafka-streaming-concepts.md +++ b/docs/streams/kafka-streaming-concepts.md @@ -248,6 +248,15 @@ Where enabled, **`optimism.broadcasted.*`** topics follow the same mapping as ** - `robinhood.raw.proto` → `BlockMessage` - `robinhood.dexpools.proto` → `DexPoolBlockMessage` — see [DEXPools Cube documentation](/docs/cubes/evm-dexpool) +#### Arc Testnet (`arc-testnet`) + +- `arc-testnet.transactions.proto` → `ParsedAbiBlockMessage` +- `arc-testnet.tokens.proto` → `TokenBlockMessage` +- `arc-testnet.dextrades.proto` → `DexBlockMessage` +- `arc-testnet.raw.proto` → `BlockMessage` + +Arc testnet is Circle's Arc Layer 1 test network (`EVM(network: arc_testnet)` in GraphQL). All `...InUSD` fields in its messages are 0 because a testnet has no token price index; native amounts are USDC, the chain's gas token. See the [Arc Testnet hub](/docs/blockchain/arc-testnet/). + ### Bitcoin - `btc.transactions.proto` — decode using Bitquery Bitcoin protobuf definitions in [Bitquery Streaming Protobuf](https://github.com/bitquery/streaming_protobuf). diff --git a/docs/streams/kafka-streams.md b/docs/streams/kafka-streams.md index 067e0190..52cd2a27 100644 --- a/docs/streams/kafka-streams.md +++ b/docs/streams/kafka-streams.md @@ -25,7 +25,7 @@ This page is the map of the Kafka section. Start with the concepts guide if Kafk | Group | Topics | Guide | |---|---|---| | Multi-chain trading | Trades, token and pair prices with USD values across the Trading cube chains | [Multi-chain trading streams](/docs/streams/protobuf/kafka-trading-topics-protobuf) | -| EVM chains | Transactions, calls, events, transfers, balances and blocks for Ethereum, BNB Chain, Base, Polygon, Optimism and Robinhood Chain | [EVM protobuf streams](/docs/streams/protobuf/chains/EVM-protobuf) | +| EVM chains | Transactions, calls, events, transfers, balances and blocks for Ethereum, BNB Chain, Base, Polygon, Optimism, Robinhood Chain and Arc testnet | [EVM protobuf streams](/docs/streams/protobuf/chains/EVM-protobuf) | | Solana | Shred-level transactions, DEX trades, transfers and balances, ahead of block confirmation | [Solana shred streams](/docs/streams/protobuf/chains/Solana-protobuf) | | Solana perpetuals | Orders, fills, positions, PnL, liquidations and prices | [Solana perpetuals stream](/docs/streams/protobuf/chains/Solana-perpetual-protobuf) | | Tron | Transactions, transfers, balances and blocks | [Tron protobuf streams](/docs/streams/protobuf/chains/Tron-protobuf) | @@ -93,7 +93,7 @@ Change `bid:eth` to `bid:solana`, `bid:bsc`, `bid:base` or another chain id from { q: "How long are Kafka messages retained?", a: "Four hours. A consumer can replay anything within that window from an offset; anything older is gone, so keep consumers running and watch lag." }, { q: "Kafka or WebSocket subscriptions: which should I use?", a: "Both carry the same rows. Kafka has lower latency, replays from offsets without gaps and lets several consumers split one feed, but runs server-side only with a fixed schema. WebSocket subscriptions work from a browser, can be filtered and reshaped in the query, and run in the IDE. Prototype on WebSocket, move to Kafka when latency or reliability matters." }, { q: "Can I filter a Kafka topic on the server?", a: "No. Topics have a fixed protobuf schema and carry every message for that chain and data type; filtering happens in your consumer. The filtering guide shows the patterns, and the GraphQL subscription of the same data is the place to filter server-side." }, - { q: "Which chains have Kafka topics?", a: "Ethereum, BNB Chain, Base, Polygon, Optimism, Robinhood Chain, Bitcoin, Solana (including shred-level and perpetuals topics), Tron and Hyperliquid, plus the multi-chain trading topics with USD prices. The complete list with topic names is on the concepts page." }, + { q: "Which chains have Kafka topics?", a: "Ethereum, BNB Chain, Base, Polygon, Optimism, Robinhood Chain, Arc testnet, Bitcoin, Solana (including shred-level and perpetuals topics), Tron and Hyperliquid, plus the multi-chain trading topics with USD prices. The complete list with topic names is on the concepts page." }, ]} /> diff --git a/docs/usecases/ohlcv-complete-guide.md b/docs/usecases/ohlcv-complete-guide.md index 1cd9904c..5c5f439f 100644 --- a/docs/usecases/ohlcv-complete-guide.md +++ b/docs/usecases/ohlcv-complete-guide.md @@ -85,6 +85,7 @@ To fetch OHLC (Open, High, Low, Close) data for a specific token pair on EVM-com - **Base** → `EVM(network: base)` - **Optimism** → `EVM(network: optimism)` - **Robinhood** → `EVM(network: robinhood)` +- **Arc Testnet** → `EVM(network: arc_testnet)` (chain-level cubes only; no `Trading` cube, USD fields are 0) For full API documentation, refer to: [Get OHLC Data for a Particular Token Pair](/docs/blockchain/Ethereum/dextrades/token-trades-apis/#get-ohlc-data-for-a-particular-token-pair). diff --git a/sidebars.js b/sidebars.js index 3d1d4978..dfa55c2a 100644 --- a/sidebars.js +++ b/sidebars.js @@ -918,6 +918,22 @@ const sidebars = { "blockchain/robinhood/robinhood-token-supply", ], }, + { + type: "category", + label: "Arc Testnet", + link: { + type: "doc", + id: "blockchain/arc-testnet/index", + }, + items: [ + "blockchain/arc-testnet/arc-testnet-trades-api", + "blockchain/arc-testnet/arc-testnet-transfers-api", + "blockchain/arc-testnet/arc-testnet-events-api", + "blockchain/arc-testnet/arc-testnet-calls-api", + "blockchain/arc-testnet/arc-testnet-transactions-api", + "blockchain/arc-testnet/arc-testnet-balances-api", + ], + }, { type: "category", label: "x402 Protocol",