The quickest way to start building on Blast with Quicknode is by sending a JSON-RPC request to your endpoint. In this guide, you'll create an endpoint, copy its provider URL, and make your first request. Code samples are available in cURL as well as popular SDKs and programming languages.

Get Your Blast Endpoint

1

Maak een Quicknode aan

Meld je hier aan als je dat nog niet hebt gedaan.

2

Ga naar je dashboard

Open het Endpoints-dashboard via het menu in de linkerzijbalk om al je blockchain-eindpunten te beheren

3

Een nieuw endpoint aanmaken

Click Create an Endpoint in the top-right corner, select Blast as your blockchain, then select your preferred network

4

Kopieer de URL’s van je providers

Houd de HTTP-URL bij de hand. Je hebt deze nodig voor de verzoeken hieronder.

Meer informatie over het dashboard

Bekijk onze handleiding voor een gedetailleerd overzicht van het Quicknode

Dien je eerste aanvraag in

Your endpoint is ready. Now, let's make your first call to the Blast blockchain. We'll use the eth_blockNumber method, which returns the latest block number. Select your preferred language or SDK and follow the steps below to send your first request.

cURL

1

Controleer of cURL is geïnstalleerd

De meeste op *nix gebaseerde systemen bieden standaard ondersteuning voor cURL. Open je terminal en controleer de cURL-versie door het onderstaande commando uit te voeren:

curl --versie

2

Een JSON-RPC-verzoek verzenden

Kopieer en plak de volgende cURL-opdracht in je terminal om het laatste bloknummer op te halen:

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

3

Voorbeeldantwoord

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

SDK

1

Je project opzetten

Controleer eerst of Node.js is geïnstalleerd met het commando `node --version`. Als het niet is geïnstalleerd, download het dan via https://nodejs.org. Maak vervolgens een nieuwe map aan en start een Node.js-project op:

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

2

Installeer de SDK

Installeer het SDK :

npm installerensdk

3

Maak je hoofdbestand aan

Maak een bestand index.js aan voor je code:

touch index.js

4

Voeg deze code toe aan je index.js-bestand

Kopieer deze code en plak hem in je index.js-bestand:

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

Voer je project uit

Voer je script uit om het laatste bloknummer te zien:

node index.js

Python

1

Je project opzetten

Maak een nieuwe map aan voor je Python-project:

mkdir blast-python-quickstart
cd blast-python-quickstart

2

Een virtuele omgeving aanmaken en activeren

Maak een virtuele omgeving aan om afhankelijkheden te beheren:

python3 -m venv venv
bron venv/bin/activate

3

Installatieverzoeken

Installeer de requests-bibliotheek om HTTP-verzoeken te doen:

pip installeren verzoeken

4

Maak een Python-script (app.py)

Maak een Python-bestand aan met de volgende 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

Voer het script uit

Voer je Python-script uit:

python app.py

JavaScript

1

Je project opzetten

Maak een nieuwe map aan en start een Node.js-project op:

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

2

Maak een JavaScript-bestand aan (app.js)

Maak een bestand app.js aan met de volgende code (met behulp van de native fetch-functie die beschikbaar is in Node.js 18 en hoger):

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

Voer het script uit

Voer je JavaScript-script uit:

node app.js

Ruby

1

Je project opzetten

Maak een nieuwe map aan voor je Ruby-project:

mkdir blast-ruby-quickstart
cd blast-ruby-quickstart

2

Controleer of Ruby is geïnstalleerd

Controleer of Ruby op je systeem is geïnstalleerd. Zo niet, installeer het dan via https://ruby-lang.org:

ruby --versie

3

Maak een Ruby-script (main.rb)

Maak een bestand `main.rb` aan met de volgende 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

Voer het script uit

Voer je Ruby-script uit om het laatste bloknummer te zien:

ruby main.rb

Ga

1

Je project opzetten

Maak een nieuwe map aan voor je Go-project:

mkdir blast-go-quickstart
cd blast-go-quickstart

2

Controleer de Go-installatie

Controleer of Go op uw systeem is geïnstalleerd. Zo niet, installeer het dan via https://golang.org:

go-versie

3

Maak een Go-script (main.go)

Maak een bestand `main.go` aan met de volgende 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

Voer het script uit

Voer je Go-script uit om het laatste bloknummer te zien:

voer main.go uit

Ethers.js

1

Je project opzetten

Maak een nieuwe map aan en start een Node.js-project op (ervan uitgaande dat Node.js al is geïnstalleerd):

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

2

Installeer ethers.js

Installeer de ethers.js-bibliotheek voor Ethereum :

npm installeren ethers

3

Maak je hoofdbestand (index.js) aan

Maak een bestand index.js aan met de volgende 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

Voer je project uit

Voer je script uit om het laatste bloknummer te zien:

node index.js

Web3.py

1

Je project opzetten

Maak een nieuwe map aan voor je web3.py-project:

mkdir blast-web3py-quickstart
cd blast-web3py-quickstart

2

Installeer web3.py (als dit nog niet is geïnstalleerd)

Controleer of web3.py is geïnstalleerd met `pip list | grep web3`. Als het niet wordt gevonden, installeer het dan:

pip installeren web3

3

Maak een Python-script (main.py)

Maak een bestand `main.py` aan met de volgende 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

Je project opzetten

Maak een nieuwe map aan voor je eth.rb-project:

mkdir blast-ethrb-quickstart
cd blast-ethrb-quickstart

2

Installeer eth.rb (als dit nog niet is geïnstalleerd)

Controleer of eth.rb is geïnstalleerd met `gem list eth`. Als het niet wordt gevonden, installeer het dan:

edelsteen installeren eth

3

Maak een Ruby-script (main.rb)

Maak een bestand `main.rb` aan met de volgende 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

Voer het script uit

Voer je Ruby-script uit om het laatste bloknummer te zien:

ruby main.rb

Ethgo

1

Je project opzetten

Maak een nieuwe map aan voor je Ethgo-project:

mkdir blast-ethgo-quickstart
cd blast-ethgo-quickstart

2

Initialiseer de Go-module en installeer ethgo

Maak een go.mod-bestand aan om afhankelijkheden bij te houden en installeer vervolgens de ethgo SDK:

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

3

Maak een Go-script (main.go)

Maak een bestand `main.go` aan met de volgende 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

Voer het script uit

Voer je Go-script uit om het laatste bloknummer te zien:

voer main.go uit

Als je meer wilt weten over het doen van API-verzoeken, bekijk dan onze handleidingen en voorbeeldapps.

Overzicht van de API

Discover Supported Blast APIs, Networks, Chain Configurations, and compatible Quicknode Products

Eindpunten van providers

Learn how to set up and configure your Blast RPC endpoints for development and production use

Endpoint

Beveilig uw eindpunten met token-authenticatie, rate-limiting, whitelisting, JWT en beproefde beveiligingspraktijken

Foutverwijzing

Reference document for common Blast RPC error codes and troubleshooting tips

Marktplaats-uitbreidingen

Discover powerful add-ons and extensions to enhance your Blast development workflow

Gidsen

Explore comprehensive Blast development guides and best practices to accelerate your blockchain application development

We ❤️ feedback!

Mocht je opmerkingen of vragen hebben over deze documentatie, laat het ons dan weten. We horen graag van je!