Create an Elysium Testnet endpoint and call eth_blockNumber to read the latest block number. Elysium Testnet uses chain ID 99801 and HYPE for gas.

Get Your Elysium Endpoint

1

Create a Quicknode account

Sign up here if you haven't already.

2

Go to your dashboard

Go to your Quicknode dashboard, then select Endpoints from the left sidebar.

3

Create a new endpoint

Click Create Endpoint in the top-right corner. Select Elysium as the chain, click Continue, then select your preferred network.

4

Copy your provider URLs

Keep the HTTP URL handy. You'll use it in your requests below.

Send Your First Request

Use eth_blockNumber with your endpoint URL. Select a language below and run the request.

cURL

1

Check cURL installation

Most *nix based systems have cURL support out of the box. Open your terminal and check the cURL version by running the command below:

curl --version

2

Send a JSON-RPC request

In your terminal, copy and paste the following cURL command to retrieve the latest block number:

curl -X POST YOUR_QUICKNODE_ENDPOINT_URL/ \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

3

Sample Response

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1234567"
}

SDK

1

Set up your project

First, verify Node.js is installed with node --version. If not installed, download it from https://nodejs.org. Then create a new directory and initialize a Node.js project:

mkdir elysium-api-quickstart
cd elysium-api-quickstart
npm init -y

2

Install the SDK

Install the SDK package:

npm install @quicknode/sdk

3

Create your main file

Create an index.js file for your code:

touch index.js

4

Add this code to your index.js file

Copy and paste this code into your index.js file:

const { Core } = require('@quicknode/sdk');

const main = async () => {
  const core = new Core({
    endpointUrl: 'YOUR_QUICKNODE_ENDPOINT_URL/',
  });

  const blockNumber = await core.client.request({
    method: 'eth_blockNumber',
  });

  console.log('Block number:', parseInt(blockNumber, 16));
};

main();

5

Run your project

Execute your script to see the latest block number:

node index.js

Python

1

Set up your project

Create a new directory for your Python project:

mkdir elysium-python-quickstart
cd elysium-python-quickstart

2

Create and activate a virtual environment

Create a virtual environment to manage dependencies:

python3 -m venv venv
source venv/bin/activate

3

Install requests

Install the requests library for making HTTP requests:

pip install requests

4

Create a Python script (app.py)

Create a Python file with the following code:

import requests
import json

# Your Quicknode endpoint URL
endpoint_url = "YOUR_QUICKNODE_ENDPOINT_URL/"

# JSON-RPC request payload
payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_blockNumber",
    "params": []
}

# Make the request
response = requests.post(endpoint_url, json=payload)
result = response.json()

print("Latest block number (hex):", result["result"])
print("Latest block number (decimal):", int(result["result"], 16))

5

Run the script

Execute your Python script:

python app.py

JavaScript

1

Set up your project

Create a new directory and initialize a Node.js project:

mkdir elysium-js-quickstart
cd elysium-js-quickstart
npm init -y

2

Create a JavaScript file (app.js)

Create an app.js file with the following code (using native fetch available in Node.js 18+):

const url = 'YOUR_QUICKNODE_ENDPOINT_URL/';
const options = {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'eth_blockNumber',
    params: [],
    id: 1
  })
};

async function main() {
  try {
    const response = await fetch(url, options);
    const data = await response.json();
    console.log('Block Number (hex):', data.result);
    console.log('Block Number (decimal):', parseInt(data.result, 16));
  } catch (error) {
    console.error('Error:', error);
  }
}

main();

3

Run the script

Execute your JavaScript script:

node app.js

Ruby

1

Set up your project

Create a new directory for your Ruby project:

mkdir elysium-ruby-quickstart
cd elysium-ruby-quickstart

2

Check Ruby installation

Verify Ruby is installed on your system. If not, install it from https://ruby-lang.org:

ruby --version

3

Create a Ruby script (main.rb)

Create a main.rb file with the following code:

require "uri"
require "json"
require "net/http"

url = URI("YOUR_QUICKNODE_ENDPOINT_URL/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "method": "eth_blockNumber",
  "params": [],
  "id": 1,
  "jsonrpc": "2.0"
})

response = https.request(request)
result = JSON.parse(response.read_body)
hex_result = result["result"]
decimal_result = hex_result.to_i(16)
puts "Block number (hex): #{hex_result}"
puts "Block number (decimal): #{decimal_result}"

4

Run the script

Execute your Ruby script to see the latest block number:

ruby main.rb

Go

1

Set up your project

Create a new directory for your Go project:

mkdir elysium-go-quickstart
cd elysium-go-quickstart

2

Check Go installation

Verify Go is installed on your system. If not, install it from https://golang.org:

go version

3

Create a Go script (main.go)

Create a main.go file with the following code:

package main

import (
  "encoding/json"
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  "strconv"
)

type Response struct {
  Result string `json:"result"`
}

func main() {
  url := "YOUR_QUICKNODE_ENDPOINT_URL/"
  method := "POST"

  payload := strings.NewReader(`{"method":"eth_blockNumber","params":[],"id":1,"jsonrpc":"2.0"}`)

  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }

  var response Response
  err = json.Unmarshal(body, &response)
  if err != nil {
    fmt.Println("Error parsing JSON:", err)
    return
  }

  // Convert hex to decimal
  blockNumber, err := strconv.ParseInt(response.Result, 0, 64)
  if err != nil {
    fmt.Println("Error converting hex to decimal:", err)
    return
  }

  fmt.Printf("Block number (hex): %s\n", response.Result)
  fmt.Printf("Block number (decimal): %d\n", blockNumber)
}

4

Run the script

Execute your Go script to see the latest block number:

go run main.go

Ethers.js

1

Set up your project

Create a new directory and initialize a Node.js project (assumes Node.js is already installed):

mkdir elysium-ethers-quickstart
cd elysium-ethers-quickstart
npm init -y
npm pkg set type=module

2

Install ethers.js

Install the ethers.js library for Ethereum interaction:

npm install ethers

3

Create your main file (index.js)

Create an index.js file with the following code:

import { ethers } from "ethers";

(async () => {
  const provider = new ethers.JsonRpcProvider("YOUR_QUICKNODE_ENDPOINT_URL/");
  const blockNum = await provider.getBlockNumber();
  console.log('Current block number (decimal):', blockNum);
  console.log('Block number (hex):', '0x' + blockNum.toString(16));
})();

4

Run your project

Execute your script to see the latest block number:

node index.js

Web3.py

1

Set up your project

Create a new directory for your web3.py project:

mkdir elysium-web3py-quickstart
cd elysium-web3py-quickstart

2

Install web3.py (if not already installed)

Check if web3.py is installed with `pip list | grep web3`. If not found, install it:

pip install web3

3

Create a Python script (main.py)

Create a main.py file with the following code:

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("YOUR_QUICKNODE_ENDPOINT_URL/"))

try:
  latest_block_number = w3.eth.block_number
  print(f"Latest Block Number: {latest_block_number}")
  print(f"Block number (hex): {hex(latest_block_number)}")
except Exception as e:
  print(f"Error: {e}")

Eth.rb

1

Set up your project

Create a new directory for your eth.rb project:

mkdir elysium-ethrb-quickstart
cd elysium-ethrb-quickstart

2

Install eth.rb (if not already installed)

Check if eth.rb is installed with `gem list eth`. If not found, install it:

gem install eth

3

Create a Ruby script (main.rb)

Create a main.rb file with the following code:

require 'eth'

client = Eth::Client.create "YOUR_QUICKNODE_ENDPOINT_URL/"

begin
  block_number = client.eth_block_number
  hex_result = block_number["result"]
  decimal_result = hex_result.to_i(16)
  puts "Block number (hex): #{hex_result}"
  puts "Block number (decimal): #{decimal_result}"
rescue => e
  puts "Error: #{e.message}"
end

4

Run the script

Execute your Ruby script to see the latest block number:

ruby main.rb

Ethgo

1

Set up your project

Create a new directory for your Ethgo project:

mkdir elysium-ethgo-quickstart
cd elysium-ethgo-quickstart

2

Initialize Go module and install ethgo

Initialize a go.mod file to track dependencies, then install the ethgo SDK:

go mod init elysium-ethgo-quickstart
go get github.com/umbracle/ethgo
go mod tidy

3

Create a Go script (main.go)

Create a main.go file with the following code:

package main

import (
  "fmt"
  "log"
  "github.com/umbracle/ethgo/jsonrpc"
)

func main() {
  client, err := jsonrpc.NewClient("YOUR_QUICKNODE_ENDPOINT_URL/")
  if err != nil {
    log.Fatalf("Failed to connect to Ethereum: %v", err)
  }

  blockNumber, err := client.Eth().BlockNumber()
  if err != nil {
    log.Fatalf("Failed to get latest block number: %v", err)
  }

  fmt.Printf("Latest block number (decimal): %d\n", blockNumber)
  fmt.Printf("Latest block number (hex): 0x%x\n", blockNumber)
}

4

Run the script

Execute your Go script to see the latest block number:

go run main.go

See the Elysium API overview for available methods and the endpoint guide for connection options.