Node Interface Calls - c8ntinuum Docs

Use this page when you need concrete node calls for exchange, custody, wallet, or indexer integrations. c8ntinuum exposes Ethereum-compatible JSON-RPC for EVM workflows and CometBFT, REST/LCD, and gRPC surfaces for node health and Cosmos SDK data.

Endpoint surfaces

Surface	Mainnet endpoint	Best for
EVM JSON-RPC HTTP	`https://public-evm-rpc.c8ntinuum.com`	Blocks, transactions, receipts, balances, logs, broadcasts
EVM JSON-RPC WebSocket	`wss://public-evm-rpc.c8ntinuum.com/websocket`	New block and log subscriptions
CometBFT RPC HTTP	`https://public-comet-rpc.c8ntinuum.com`	Node status, consensus block metadata, CometBFT transactions
REST/LCD	`https://public-comet-grpc-web.c8ntinuum.io`	Cosmos account and transaction queries

For all public endpoint options and rate limits, see RPC Providers.

EVM JSON-RPC with curl

Query the current block height:

curl -X POST https://public-evm-rpc.c8ntinuum.com \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Fetch a block by height. Use a hex quantity such as 0x10d4f; set the second parameter to true when you need full transaction objects:

curl -X POST https://public-evm-rpc.c8ntinuum.com \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["0x10d4f",true],"id":1}'

Fetch transaction details and its execution result:

TX_HASH="0x..."

curl -X POST https://public-evm-rpc.c8ntinuum.com \
  -H "Content-Type: application/json" \
  -d "{\"jsonrpc\":\"2.0\",\"method\":\"eth_getTransactionByHash\",\"params\":[\"$TX_HASH\"],\"id\":1}"

curl -X POST https://public-evm-rpc.c8ntinuum.com \
  -H "Content-Type: application/json" \
  -d "{\"jsonrpc\":\"2.0\",\"method\":\"eth_getTransactionReceipt\",\"params\":[\"$TX_HASH\"],\"id\":2}"

Query ERC-20 Transfer logs for a bounded range: The documented public EVM profile caps eth_getLogs at 10000 blocks and 10000 returned logs per request.

TOKEN="0x..."
TRANSFER_TOPIC="0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"

curl -X POST https://public-evm-rpc.c8ntinuum.com \
  -H "Content-Type: application/json" \
  -d "{
    \"jsonrpc\":\"2.0\",
    \"method\":\"eth_getLogs\",
    \"params\":[{
      \"address\":\"$TOKEN\",
      \"fromBlock\":\"0x10d00\",
      \"toBlock\":\"0x10dff\",
      \"topics\":[\"$TRANSFER_TOPIC\"]
    }],
    \"id\":3
  }"

Broadcast a signed transaction:

RAW_TX="0x..."

curl -X POST https://public-evm-rpc.c8ntinuum.com \
  -H "Content-Type: application/json" \
  -d "{\"jsonrpc\":\"2.0\",\"method\":\"eth_sendRawTransaction\",\"params\":[\"$RAW_TX\"],\"id\":4}"

JavaScript

import { JsonRpcProvider, id } from "ethers";

const provider = new JsonRpcProvider("https://public-evm-rpc.c8ntinuum.com");

const height = await provider.getBlockNumber();
const block = await provider.send("eth_getBlockByNumber", [
  "0x" + height.toString(16),
  true,
]);

const tx = await provider.getTransaction("0x...");
const receipt = await provider.getTransactionReceipt("0x...");
const fromBlock = Math.max(0, height - 500);

const logs = await provider.getLogs({
  address: "0xc8Fb80fCc03f699C70ff0CC08C09106288888888",
  topics: [id("Transfer(address,address,uint256)")],
  fromBlock,
  toBlock: height,
});

const sent = await provider.broadcastTransaction("0xSignedRawTransaction");
console.log({
  height,
  blockHash: block.hash,
  txHash: tx?.hash,
  status: receipt?.status,
  logCount: logs.length,
  broadcastHash: sent.hash,
});

Java

import java.math.BigInteger;
import org.web3j.protocol.Web3j;
import org.web3j.protocol.core.DefaultBlockParameterName;
import org.web3j.protocol.core.DefaultBlockParameterNumber;
import org.web3j.protocol.core.methods.response.EthBlock;
import org.web3j.protocol.core.methods.response.EthBlockNumber;
import org.web3j.protocol.core.methods.response.EthGetTransactionReceipt;
import org.web3j.protocol.core.methods.response.EthLog;
import org.web3j.protocol.core.methods.response.EthSendTransaction;
import org.web3j.protocol.core.methods.response.EthTransaction;
import org.web3j.protocol.http.HttpService;
import org.web3j.protocol.core.methods.request.EthFilter;

Web3j web3j = Web3j.build(new HttpService("https://public-evm-rpc.c8ntinuum.com"));

EthBlockNumber blockNumber = web3j.ethBlockNumber().send();
BigInteger height = blockNumber.getBlockNumber();

EthBlock block = web3j
    .ethGetBlockByNumber(new DefaultBlockParameterNumber(height), true)
    .send();

EthTransaction tx = web3j.ethGetTransactionByHash("0x...").send();
EthGetTransactionReceipt receipt = web3j.ethGetTransactionReceipt("0x...").send();

EthFilter filter = new EthFilter(
    new DefaultBlockParameterNumber(height.subtract(BigInteger.valueOf(500))),
    DefaultBlockParameterName.LATEST,
    "0xc8Fb80fCc03f699C70ff0CC08C09106288888888");
filter.addSingleTopic("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef");
EthLog logs = web3j.ethGetLogs(filter).send();

EthSendTransaction sent = web3j.ethSendRawTransaction("0xSignedRawTransaction").send();

Go

package main

import (
	"context"
	"math/big"

	"github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/ethclient"
)

func main() {
	ctx := context.Background()
	client, err := ethclient.DialContext(ctx, "https://public-evm-rpc.c8ntinuum.com")
	if err != nil {
		panic(err)
	}

	height, err := client.BlockNumber(ctx)
	if err != nil {
		panic(err)
	}

	block, err := client.BlockByNumber(ctx, new(big.Int).SetUint64(height))
	if err != nil {
		panic(err)
	}

	txHash := common.HexToHash("0x...")
	tx, pending, err := client.TransactionByHash(ctx, txHash)
	if err != nil {
		panic(err)
	}

	receipt, err := client.TransactionReceipt(ctx, txHash)
	if err != nil {
		panic(err)
	}
	fromBlock := uint64(0)
	if height > 500 {
		fromBlock = height - 500
	}

	query := ethereum.FilterQuery{
		FromBlock: new(big.Int).SetUint64(fromBlock),
		ToBlock:   new(big.Int).SetUint64(height),
		Addresses: []common.Address{common.HexToAddress("0xc8Fb80fCc03f699C70ff0CC08C09106288888888")},
		Topics: [][]common.Hash{{
			common.HexToHash("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"),
		}},
	}
	logs, err := client.FilterLogs(ctx, query)
	if err != nil {
		panic(err)
	}

	// Broadcast a signed transaction returned by your offline signer:
	// var signed *types.Transaction
	// err = client.SendTransaction(ctx, signed)

	_, _, _, _ = block, tx, pending, receipt
	_ = logs
}

Rust

use alloy::primitives::{address, B256};
use alloy::providers::{Provider, ProviderBuilder};
use alloy::rpc::types::{BlockNumberOrTag, Filter};

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let provider = ProviderBuilder::new().on_http(
        "https://public-evm-rpc.c8ntinuum.com".parse()?,
    );

    let height = provider.get_block_number().await?;
    let block = provider
        .get_block_by_number(BlockNumberOrTag::Number(height), true.into())
        .await?;

    let tx_hash: B256 = "0x...".parse()?;
    let tx = provider.get_transaction_by_hash(tx_hash).await?;
    let receipt = provider.get_transaction_receipt(tx_hash).await?;

    let transfer_topic: B256 =
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
            .parse()?;
    let filter = Filter::new()
        .address(address!("c8fb80fcc03f699c70ff0cc08c09106288888888"))
        .event_signature(transfer_topic)
        .from_block(height.saturating_sub(500))
        .to_block(height);
    let logs = provider.get_logs(&filter).await?;

    let raw_tx = "0xSignedRawTransaction".parse()?;
    let pending = provider.send_raw_transaction(&raw_tx).await?;

    println!(
        "height={height} block={:?} tx={:?} receipt={:?} logs={} sent={:?}",
        block.map(|b| b.header.hash),
        tx.map(|t| t.hash),
        receipt.map(|r| r.status()),
        logs.len(),
        pending.tx_hash(),
    );

    Ok(())
}

CometBFT RPC

Use CometBFT RPC for node status, consensus block metadata, and CometBFT transaction queries.

# Current node status and latest block height
curl -s "https://public-comet-rpc.c8ntinuum.com/status"

# Block by height
curl -s "https://public-comet-rpc.c8ntinuum.com/block?height=123456"

# Transaction by CometBFT hash
curl -s "https://public-comet-rpc.c8ntinuum.com/tx?hash=0x...&prove=true"

# Search indexed transactions when the node profile supports it
curl -s --get "https://public-comet-rpc.c8ntinuum.com/tx_search" \
  --data-urlencode 'query=tx.height=123456'

REST and account queries

Use REST/LCD when you need Cosmos SDK account state or Cosmos transaction data.

# Account metadata by c8... address
curl -s "https://public-comet-grpc-web.c8ntinuum.io/cosmos/auth/v1beta1/accounts/c8..."

# Cosmos transaction by hash
curl -s "https://public-comet-grpc-web.c8ntinuum.io/cosmos/tx/v1beta1/txs/0x..."

Operational notes

Treat public endpoint limits as provider policy, not protocol limits.
Keep long historical jobs bounded by block range and retryable by cursor. eth_getLogs requests should stay within the 10000 block and 10000 log caps.
Credit deposits from receipts and logs, not from pending transaction data.
Use eth_sendRawTransaction for offline-signed EVM transactions.
Run archive or indexer infrastructure when you need complete historical state from genesis.

​Endpoint surfaces

​EVM JSON-RPC with curl

​JavaScript

​Java

​Go

​Rust

​CometBFT RPC

​REST and account queries

​Operational notes