JOC QuickStart

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

建立Quicknode

若您尚未註冊，請點此註冊。

前往您的儀表板

從左側邊欄選單開啟「端點」儀表板，以管理您所有的區塊鏈端點

建立新的endpoint

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

複製您的服務供應商網址

請將該 HTTP URL 備妥。您將在以下請求中使用它。

進一步了解儀表板

如需了解Quicknode 詳細操作指南，請參閱我們的指南

發送您的第一項請求

Your endpoint is ready. Now, let's make your first call to the JOC blockchain. We'll use the eth_blockNumber 此方法會傳回最新的區塊編號。 請選擇您偏好的語言或SDK 依照以下步驟發送您的第一個請求.

檢查 cURL 的安裝狀況

大多數基於 *nix 的系統預設即支援 cURL。請開啟終端機，並執行以下指令以檢查 cURL 的版本：

curl --version

傳送一個 JSON-RPC 請求

請在終端機中複製並貼上以下 cURL 指令，以取得最新的區塊編號：

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

範例回應

{
  "jsonrpc": "2.0",
  "id": 1,
  「結果」: "0x1234567"
}

設定您的專案

首先，請使用 `node --version` 確認是否已安裝 Node.js。若尚未安裝，請從 https://nodejs.org 下載。接著建立一個新目錄，並初始化一個 Node.js 專案：

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

安裝SDK

安裝SDK ：

npm 安裝sdk

建立您的主檔案

為您的程式碼建立一個 index.js 檔案：

touch index.js

將這段程式碼加入您的 index.js 檔案中

請將這段程式碼複製並貼到您的 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();

執行您的專案

執行您的腳本以查看最新的區塊編號：

node index.js

設定您的專案

為您的 Python 專案建立一個新目錄：

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

建立並啟用虛擬環境

建立一個虛擬環境來管理依賴項：

python3 -m venv venv
source venv/bin/activate

安裝請求

安裝 requests 函式庫，以便發送 HTTP 請求：

pip 安裝 requests

建立一個 Python 腳本（app.py）

建立一個包含以下程式碼的 Python 檔案：

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))

執行該腳本

執行您的 Python 腳本：

python app.py

設定您的專案

建立一個新目錄並初始化一個 Node.js 專案：

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

建立一個 JavaScript 檔案（app.js）

建立一個名為 app.js 的檔案，並加入以下程式碼（使用 Node.js 18 及以上版本中內建的 fetch 功能）：

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();

執行該腳本

執行您的 JavaScript 腳本：

node app.js

設定您的專案

為您的 Ruby 專案建立一個新目錄：

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

檢查 Ruby 的安裝狀況

請確認您的系統上已安裝 Ruby。若尚未安裝，請從 https://ruby-lang.org 進行安裝：

ruby --version

建立一個 Ruby 腳本（main.rb）

建立一個名為 main.rb 的檔案，並輸入以下程式碼：

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}"

執行該腳本

執行您的 Ruby 腳本，以查看最新的區塊編號：

Ruby main.rb

設定您的專案

為您的 Go 專案建立一個新目錄：

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

檢查圍棋佈局

請確認您的系統已安裝 Go。若尚未安裝，請從 https://golang.org 進行安裝：

go version

建立一個 Go 腳本（main.go）

建立一個名為 main.go 的檔案，並輸入以下程式碼：

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)
}

執行該腳本

執行您的 Go 腳本，以查看最新的區塊編號：

執行 main.go

設定您的專案

建立一個新目錄並初始化一個 Node.js 專案（假設已安裝 Node.js）：

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

安裝 ethers.js

安裝 ethers.js 函式庫以Ethereum ：

npm 安裝 ethers

建立您的主檔案（index.js）

建立一個名為 index.js 的檔案，並放入以下程式碼：

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));
})();

執行您的專案

執行您的腳本以查看最新的區塊編號：

node index.js

設定您的專案

為您的 web3.py 專案建立一個新目錄：

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

安裝 web3.py（若尚未安裝）

請使用 `pip list | grep web3` 檢查是否已安裝 web3.py。若未找到，請安裝：

pip 安裝 web3

建立一個 Python 腳本（main.py）

建立一個名為 main.py 的檔案，並輸入以下程式碼：

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 專案建立一個新目錄：

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

安裝 eth.rb（若尚未安裝）

請使用 `gem list eth` 檢查是否已安裝 eth.rb。若未找到，請安裝它：

gem 安裝 eth

建立一個 Ruby 腳本（main.rb）

建立一個名為 main.rb 的檔案，並輸入以下程式碼：

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}"
結束

執行該腳本

執行您的 Ruby 腳本，以查看最新的區塊編號：

Ruby main.rb

設定您的專案

為您的 Ethgo 專案建立一個新目錄：

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

初始化 Go 模組並安裝 ethgo

建立一個 go.mod 檔案以追蹤依賴項，然後安裝 ethgoSDK：

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

建立一個 Go 腳本（main.go）

建立一個名為 main.go 的檔案，並輸入以下程式碼：

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)
}

執行該腳本

執行您的 Go 腳本，以查看最新的區塊編號：

執行 main.go

如果您想進一步了解如何發送 API 請求，請參閱我們的指南和範例應用程式。

API 概覽

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

供應商端點

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

Endpoint

透過令牌驗證、速率限制、白名單、JWT 以及最佳安全實務，確保您的端點安全

錯誤參考

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

附加元件

Discover endpoint add-ons that extend your Japan Open Chain development workflow

Get Your JOC Endpoint​

建立Quicknode

前往您的儀表板

建立新的endpoint

複製您的服務供應商網址

發送您的第一項請求​

檢查 cURL 的安裝狀況

傳送一個 JSON-RPC 請求

範例回應

設定您的專案

安裝SDK

建立您的主檔案

將這段程式碼加入您的 index.js 檔案中

執行您的專案

設定您的專案

建立並啟用虛擬環境

安裝請求

建立一個 Python 腳本（app.py）

執行該腳本

設定您的專案

建立一個 JavaScript 檔案（app.js）

執行該腳本

設定您的專案

檢查 Ruby 的安裝狀況

建立一個 Ruby 腳本（main.rb）

執行該腳本

設定您的專案

檢查圍棋佈局

建立一個 Go 腳本（main.go）

執行該腳本

設定您的專案

安裝 ethers.js

建立您的主檔案（index.js）

執行您的專案

設定您的專案

安裝 web3.py（若尚未安裝）

建立一個 Python 腳本（main.py）

設定您的專案

安裝 eth.rb（若尚未安裝）

建立一個 Ruby 腳本（main.rb）

執行該腳本

設定您的專案

初始化 Go 模組並安裝 ethgo

建立一個 Go 腳本（main.go）

執行該腳本

API 概覽

供應商端點

Endpoint

錯誤參考

附加元件

Get Your JOC Endpoint

發送您的第一項請求