The quickest way to start building on JOC 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 JOC Endpoint

1

Crear una cuenta en Quicknode

Regístrate aquí si aún no lo has hecho.

2

Ve a tu panel de control

Abre el panel de control de Endpoints desde el menú de la barra lateral izquierda para gestionar todos tus puntos de conexión de la cadena de bloques

3

Crear un nuevo punto final

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

4

Copia las URL de tus proveedores

Ten a mano la URL HTTP. La vas a utilizar en las solicitudes que vas a realizar a continuación.

Más información sobre el panel de control

Si quieres ver una explicación detallada del panel de control de Quicknode, echa un vistazo a nuestra guía

Envía tu primera solicitud

Your endpoint is ready. Now, let's make your first call to the JOC blockchain. We'll use the eth_blockNumber método, que devuelve el número de bloque más reciente. Selecciona tu idioma o SDK preferido y sigue los pasos que se indican a continuación para enviar tu primera solicitud.

cURL

1

Comprobar la instalación de cURL

La mayoría de los sistemas basados en *nix son compatibles con cURL de serie. Abre el terminal y comprueba la versión de cURL ejecutando el siguiente comando:

curl --versión

2

Enviar una solicitud JSON-RPC

En tu terminal, copia y pega el siguiente comando de cURL para obtener el último número de bloque:

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

3

Ejemplo de respuesta

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

SDK de Quicknode

1

Configura tu proyecto

En primer lugar, comprueba que Node.js esté instalado ejecutando el comando `node --version`. Si no está instalado, descárgalo desde https://nodejs.org. A continuación, crea un nuevo directorio e inicializa un proyecto de Node.js:

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

2

Instala el SDK de Quicknode

Instala el paquete SDK de Quicknode:

npm instalar @quicknode/sdk

3

Crea tu archivo principal

Crea un archivo «index.js» para tu código:

touch index.js

4

Añade este código a tu archivo index.js

Copia y pega este código en tu archivo index.js:

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

Ejecuta tu proyecto

Ejecuta tu script para ver el último número de bloque:

nodo index.js

Python

1

Configura tu proyecto

Crea un nuevo directorio para tu proyecto de Python:

mkdir joc-python-quickstart
cd joc-python-quickstart

2

Crear y activar un entorno virtual

Crear un entorno virtual para gestionar las dependencias:

python3 -m venv venv
source venv/bin/activate

3

Solicitudes de instalación

Instala la biblioteca «requests» para realizar solicitudes HTTP:

pip instalar requests

4

Crea un script en Python (app.py)

Crea un archivo de Python con el siguiente código:

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

Ejecuta el script

Ejecuta tu script de Python:

python app.py

JavaScript

1

Configura tu proyecto

Crea un nuevo directorio e inicializa un proyecto de Node.js:

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

2

Crea un archivo JavaScript (app.js)

Crea un archivo «app.js» con el siguiente código (utilizando la función «fetch» nativa disponible en Node.js 18 y versiones posteriores):

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

Ejecuta el script

Ejecuta tu script de JavaScript:

nodo app.js

Rubí

1

Configura tu proyecto

Crea un nuevo directorio para tu proyecto de Ruby:

mkdir joc-ruby-quickstart
cd joc-ruby-quickstart

2

Comprobar la instalación de Ruby

Comprueba que Ruby esté instalado en tu sistema. Si no es así, instálalo desde https://ruby-lang.org:

ruby --versión

3

Crea un script en Ruby (main.rb)

Crea un archivo «main.rb» con el siguiente código:

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

Ejecuta el script

Ejecuta tu script de Ruby para ver el último número de bloque:

ruby main.rb

Ir

1

Configura tu proyecto

Crea un nuevo directorio para tu proyecto de Go:

mkdir joc-go-quickstart
cd joc-go-quickstart

2

Comprobar la instalación de Go

Comprueba que Go esté instalado en tu sistema. Si no es así, instálalo desde https://golang.org:

go versión

3

Crea un script en Go (main.go)

Crea un archivo «main.go» con el siguiente código:

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

Ejecuta el script

Ejecuta tu script de Go para ver el último número de bloque:

ejecuta main.go

Ethers.js

1

Configura tu proyecto

Crea un nuevo directorio e inicializa un proyecto de Node.js (se da por hecho que Node.js ya está instalado):

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

2

Instala ethers.js

Instala la biblioteca ethers.js para interactuar con Ethereum:

npm instalar ethers

3

Crea tu archivo principal (index.js)

Crea un archivo index.js con el siguiente código:

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

Ejecuta tu proyecto

Ejecuta tu script para ver el último número de bloque:

nodo index.js

Web3.py

1

Configura tu proyecto

Crea un nuevo directorio para tu proyecto web3.py:

mkdir joc-web3py-quickstart
cd joc-web3py-quickstart

2

Instala web3.py (si aún no lo tienes instalado)

Comprueba si web3.py está instalado con `pip list | grep web3`. Si no lo encuentras, instálalo:

pip instalar web3

3

Crea un script en Python (main.py)

Crea un archivo «main.py» con el siguiente código:

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

Configura tu proyecto

Crea un nuevo directorio para tu proyecto eth.rb:

mkdir joc-ethrb-quickstart
cd joc-ethrb-quickstart

2

Instala eth.rb (si aún no está instalado)

Comprueba si eth.rb está instalado con el comando `gem list eth`. Si no lo encuentras, instálalo:

gem instalar eth

3

Crea un script en Ruby (main.rb)

Crea un archivo «main.rb» con el siguiente código:

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

Ejecuta el script

Ejecuta tu script de Ruby para ver el último número de bloque:

ruby main.rb

Ethgo

1

Configura tu proyecto

Crea un nuevo directorio para tu proyecto Ethgo:

mkdir joc-ethgo-quickstart
cd joc-ethgo-quickstart

2

Inicializar el módulo de Go e instalar ethgo

Inicializa un archivo «go.mod» para gestionar las dependencias y, a continuación, instala el SDK de ethgo:

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

3

Crea un script en Go (main.go)

Crea un archivo «main.go» con el siguiente código:

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

Ejecuta el script

Ejecuta tu script de Go para ver el último número de bloque:

ejecuta main.go

Si quieres seguir aprendiendo a realizar solicitudes a la API, echa un vistazo a nuestras guías y aplicaciones de ejemplo.

Descripción general de la API

Discover Supported Japan Open Chain APIs, Networks, Chain Configurations, and compatible Quicknode Products

Puntos de conexión de los proveedores

Learn how to set up and configure your Japan Open Chain RPC endpoints for development and production use

Seguridad de los dispositivos finales

Protege tus dispositivos finales mediante la autenticación por token, la limitación de velocidad, las listas blancas, JWT y las mejores prácticas de seguridad

Referencia de error

Reference document for common Japan Open Chain RPC error codes and troubleshooting tips

Complementos de Marketplace

Discover powerful add-ons and extensions to enhance your Japan Open Chain development workflow

¡Nos encanta recibir comentarios!

Si tienes algún comentario o pregunta sobre esta documentación, háznoslo saber. ¡Nos encantaría saber tu opinión!