EfetuargRPC Celestia com Go

Visão geral

Go is a statically-typed, compiled language known for its simplicity, efficiency, and strong concurrency support. Follow the official installation guide to install Go. Verify the installation:

go version

É necessária autenticação para Celestia gRPC

To ensure secure access to Celestia gRPC, users are required to authenticate themselves. This authentication process is necessary before utilizing any method. Quicknode endpoints consist of two crucial components: the endpoint e o correspondente ficha. Users will need to use these two components to configure a gRPC client with authentication credentials before they make any method calls.

A autenticação para o Celestia gRPC ser efetuada de duas formas:

Autenticação básica
Autenticação x-token

Ao longo desta documentação, iremos referir-nos tanto ao getClientWithBasicAuth ou getClientWithXToken funções que demonstram como lidar com estes diferentes mecanismos de autenticação.

Autenticação básica

O getClientWithBasicAuth Esta função demonstra como gerir a autenticação utilizando a Autenticação Básica, que codifica as credenciais em base64. Segue-se a implementação do código da getClientWithBasicAuth função, bem como o basicAuth implementação das credenciais RPC:

import (
	"contexto"
	"crypto/tls"
	"encoding/base64"
	"fmt"
	"google.golang.grpc"
	"google.golang.grpc"
)

func getClientWithBasicAuth(endpoint, token string) (*grpc.ClientConn, error) {
	target := endpoint + ".celestia-mainnet.quiknode.pro:9090" // for TLS connections
	conn, err := grpc.Dial(target,
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})),
		grpc.WithPerRPCCredentials(basicAuth{
			username: endpoint,
			password: token,
		}),
	)
	if err != nil {
		return nil, fmt.Errorf("Unable to dial endpoint %w", err)
	}
	return conn, nil
}

// basicAuth implements the credentials.PerRPCCredentials interface to support basic authentication for grpc requests.
type basicAuth struct {
	username string
	password string
}

func (b basicAuth) GetRequestMetadata(ctx context.Context, in ...string) (map[string]string, error) {
	auth := b.username + ":" + b.password
	enc := base64.StdEncoding.EncodeToString([]byte(auth))
	return map[string]string{"authorization": "Basic " + enc}, nil
}

func (basicAuth) RequireTransportSecurity() bool {
	return false
}

O getClientWithBasicAuth Esta função configura um gRPC com as opções de segurança necessárias e estabelece uma ligação ao endpoint especificado endpoint porta 9090. Aceita o endpoint e o token como parâmetros de entrada e devolve uma ligação gRPC , que pode utilizar para efetuar chamadas à API autenticadas.

conn, err := getClientWithBasicAuth("ENDPOINT_NAME", "TOKEN")
if err != nil {
	log.Fatalf("err: %v", err)
}
defer conn.Close()

Autenticação x-token

O getClientWithXToken A função demonstra como gerir a autenticação utilizando um x-token. Este método anexa o token ao cabeçalho x-token de cada pedido.

import (
    "contexto"
    "crypto/tls"
    "fmt"
    "google.golang.grpc"
    "google.golang.grpc"
)

func getClientWithXToken(endpoint, token string) (*grpc.ClientConn, error) {
    target := endpoint + ".celestia-mainnet.quiknode.pro:9090" // for TLS connections
    conn, err := grpc.Dial(target,
        grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})),
        grpc.WithPerRPCCredentials(auth{
            token: token,
        }),
    )
    if err != nil {
        return nil, fmt.Errorf("Unable to dial endpoint %w", err)
    }
    return conn, nil
}

// auth implements the credentials.PerRPCCredentials interface to support x-token authentication for grpc requests.
type auth struct {
    token string
}

func (a *auth) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
    return map[string]string{
        "x-token": a.token,
    }, nil
}

func (auth) RequireTransportSecurity() bool {
    return false
}

Este método configura um gRPC de forma semelhante ao exemplo de autenticação básica, mas inclui o token de autenticação no cabeçalho x-token. Veja a seguir como pode utilizar esta função para efetuar chamadas à API:

conn, err := getClientWithXToken("ENDPOINT_NAME", "TOKEN")
if err != nil {
    log.Fatalf("err: %v", err)
}
defer conn.Close()

Iniciar um projeto Go para Celestia gRPC

A secção abaixo apresenta um processo passo a passo para configurar um ambiente Go para efetuar gRPC . As instruções incluem a instalação do Go, a configuração das dependências e a implementação de mecanismos de autenticação.

Passo 1: Criar um novo diretório de projeto

Crie um diretório específico para o seugRPC Celestia gRPC e aceda a ele:

mkdir celestia-grpc
cd celestia-grpc

Passo 2: Inicializar um módulo Go

Crie um módulo Go para o seu projeto. O nome do módulo pode corresponder ao nome do diretório ou ser um URL de repositório:

go mod initgrpc # nome do diretório

Passo 3: Instalar as dependências gRPC do Protobuf

Certifique-se de que tem ambos Vai e protoc instalado no seu computador.

Pode instalar as bibliotecas principais gRPC do Protobuf através dos seguintes comandos:

go get google.golang.org/grpc
go get google.golang.org/protobuf

Também pode definir versões diretamente no seu go.mod:

require (
    google.golang.org/grpc v1.60.0
    google.golang.org/protobuf v1.33.0
)

Em seguida, instale os plugins do protoc para o Go:

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

Certifique-se de que $GOPATH/bin está no PATH do seu sistema. Pode seguir os passos abaixo para configurar o PATH do sistema para o GO.

dica

Para utilizar as ferramentas instaladas pelo Go a nível global (por exemplo, protoc-gen-go, grpcurl), adicionar $GOPATH/bin para o seu sistema PATH.

Para macOS / Linux

Adicione ao seu ficheiro de configuração do shell:

echo 'export PATH="$PATH:$(go env GOPATH)/bin"' >> ~/.bashrc
source ~/.bashrc

Utilize o ficheiro .zshrc em vez do .bashrc se estiver a utilizar o Zsh.

Verificar:

que protoc-gen-go

Para o Windows

Abra o Menu Iniciar → procure por «Variáveis de ambiente»
Em «Variáveis do sistema», selecione «Path» → clique em «Editar»
Clique em «Novo» e adicione:

%USERPROFILE%\go\bin

Abra uma nova janela do Prompt de Comandos ou do PowerShell e verifique:

onde está o protoc-gen-go

Passo 4: Organizar o diretório do projeto

Descarregue os ficheiros Celestia oficiais Celestia a partir do repositóriocelestia. Pode utilizar os seguintes comandos:

# Create celestia folder for proto files
mkdir celestia

# Clone the repository with minimal depth
git clone https://github.com/celestiaorg/celestia-app.git --depth=1

# Copy the proto files to your working directory
cp -r celestia-app/proto/celestia/* celestia/

# Remove the cloned repository (optional)
rm -rf celestia-app

A estrutura do seu projeto deve ser a seguinte:

celestia-grpc/
├── celestia/
│   ├── blob/
│   │   └── v1/
│   │       ├── params.proto
│   │       ├── query.proto
│   │       └── tx.proto
│   ├── signal/
│   │   └── v1/
│   │       ├── query.proto
│   │       ├── tx.proto
│   │       └── upgrade.proto
│   ├── mint/
│   │   └── v1/
│   │       └── query.proto
│   └── ... (other modules)
├── go.mod

Passo 5: Descarregar todas as dependências

Agora, precisamos de criar e executar um script de configuração para descarregar automaticamente todas as dependências. Para isso, primeiro temos de criar um setup_celestia_protos.sh ficheiro:

touch executar o script setup_celestia_protos.sh

Depois de criado, copie e cole o código abaixo em setup_celestia_protos.sh ficheiro:

#!/bin/bash
set -e

echo "Setting up Celestia proto files and dependencies..."

# Create directory structure
mkdir -p celestia/{blob,signal,mint,minfee,qgb}/v1
mkdir -p celestia/core/v1/{gas_estimation,tx}
mkdir -p third_party/{gogoproto,cosmos_proto,google/api}
mkdir -p third_party/cosmos/{base/query/v1beta1,msg/v1}

# Download Celestia proto files
echo "Downloading Celestia proto files..."
git clone https://github.com/celestiaorg/celestia-app.git --depth=1 temp_celestia
cp -r temp_celestia/proto/celestia/* celestia/
rm -rf temp_celestia

# Download dependencies
echo "Downloading dependencies..."
git clone https://github.com/cosmos/gogoproto.git --depth=1 temp_gogoproto
cp temp_gogoproto/gogoproto/gogo.proto third_party/gogoproto/
rm -rf temp_gogoproto

git clone https://github.com/cosmos/cosmos-sdk.git --depth=1 temp_cosmos
cp -r temp_cosmos/proto/cosmos/base/query/v1beta1/* third_party/cosmos/base/query/v1beta1/
cp -r temp_cosmos/proto/cosmos/msg/v1/* third_party/cosmos/msg/v1/
cp -r temp_cosmos/proto/cosmos/* third_party/cosmos_proto/
rm -rf temp_cosmos

# Download cosmos_proto
git clone https://github.com/cosmos/cosmos-proto.git --depth=1 temp_cosmos_proto
cp temp_cosmos_proto/proto/cosmos_proto/cosmos.proto third_party/cosmos_proto/
rm -rf temp_cosmos_proto

git clone https://github.com/googleapis/googleapis.git --depth=1 temp_googleapis
cp temp_googleapis/google/api/annotations.proto third_party/google/api/
cp temp_googleapis/google/api/http.proto third_party/google/api/
rm -rf temp_googleapis

# Download protobuf dependencies
mkdir -p third_party/google/protobuf
curl -s https://raw.githubusercontent.com/protocolbuffers/protobuf/main/src/google/protobuf/descriptor.proto > third_party/google/protobuf/descriptor.proto
curl -s https://raw.githubusercontent.com/protocolbuffers/protobuf/main/src/google/protobuf/timestamp.proto > third_party/google/protobuf/timestamp.proto
curl -s https://raw.githubusercontent.com/protocolbuffers/protobuf/main/src/google/protobuf/field_mask.proto > third_party/google/protobuf/field_mask.proto

echo "Setup complete!"

Depois de criado, temos agora de tornar este script executável e executá-lo através dos seguintes comandos:

chmod +x setup_celestia_protos.sh
sh setup_celestia_protos.sh

Depois de o script ter sido executado com sucesso, a estrutura do seu projeto ficará da seguinte forma:

celestia-grpc/
├── celestia/
│   ├── blob/
│   │   └── v1/
│   │       ├── params.proto
│   │       ├── query.proto
│   │       └── tx.proto
│   ├── signal/
│   │   └── v1/
│   │       ├── query.proto
│   │       ├── tx.proto
│   │       └── upgrade.proto
│   ├── mint/
│   │   └── v1/
│   │       └── query.proto
│   └── ... (other modules)
├── third_party/
│   ├── gogoproto/
│   │   └── gogo.proto
│   ├── cosmos/
│   │   ├── base/
│   │   └── msg/
│   ├── cosmos_proto/
│   │   └── cosmos.proto
│   └── google/
│       └── api/
│           ├── annotations.proto
│           └── http.proto
├── go.mod

Passo 6: Gerar código Go a partir de ficheiros Proto

Importante: A chave para o sucesso na criação de protótipos é incluir o de terceiros diretório no seu caminho do proto. Isto permite que o protoc encontre todas as dependências, tais como gogoproto/gogo.proto.

Gerar o .pb.go ficheiros, executando os seguintes comandos com os caminhos corretos para os ficheiros proto:

protoc \
  --proto_path=. \
  --proto_path=./third_party \
  --go_out=. \
  --go_opt=paths=source_relative \
  --go-grpc_out=. \
  --go-grpc_opt=paths=source_relative \
  celestia/blob/v1/*.proto \
  celestia/signal/v1/*.proto \
  celestia/mint/v1/*.proto \
  celestia/minfee/v1/*.proto \
  celestia/core/v1/gas_estimation/*.proto \
  celestia/core/v1/tx/*.proto \
  celestia/core/v1/proof/*.proto

Depois de o comando ter sido executado com sucesso, irá encontrar o ficheiro gerado .pb.go ficheiros dentro do celestia diretório, organizado por módulo — como, por exemplo, blob, núcleo, taxa de cunhagem, e assim por diante.

Passo 7: Criar um ficheiro Go principal

Crie um ficheiro Go principal para implementar a lógica do cliente:

touch main.go

Pode copiar e colar o código de exemplo seguinte no seu main.go ficheiro para começar. O exemplo demonstra como interagir com ogRPC Celestia para consultar parâmetros de blobs.

package main

import (
	"contexto"
	"crypto/tls"
	"encoding/json"
	"fmt"
	"registo"
	"tempo"

	"google.golang.grpc"
	"google.golang.grpc"

	blobtypes "celestia-grpc/celestia/blob/v1"  // Your Generated .pb.go files path
)

// Quicknode endpoints consist of two crucial components: the endpoint name and the corresponding token
// For eg: QN Endpoint: https://docs-demo.celestia-mainnet.quiknode.pro/abcde123456789
// endpoint will be: docs-demo.celestia-mainnet.quiknode.pro:9090  {9090 is the port number for Celestia gRPC}
// token will be : abcde123456789

var token = "YOUR_TOKEN_NUMBER"
var endpoint = "YOUR_QN_ENDPOINT:9090"

type auth struct {
	token string
}

func (a *auth) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
	return map[string]string{"x-token": a.token}, nil
}
func (a *auth) RequireTransportSecurity() bool {
	return false
}

func main() {
	creds := credentials.NewTLS(&tls.Config{})
	opts := []grpc.DialOption{
		grpc.WithTransportCredentials(creds),
		grpc.WithPerRPCCredentials(&auth{token}),
	}

	conn, err := grpc.Dial(endpoint, opts...)
	if err != nil {
		log.Fatalf("Failed to connect: %v", err)
	}
	defer conn.Close()

	client := blobtypes.NewQueryClient(conn)

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	// Query blob parameters
	resp, err := client.Params(ctx, &blobtypes.QueryParamsRequest{})
	if err != nil {
		log.Fatalf("Failed to query blob parameters: %v", err)
	}

	// Pretty print the response
	jsonData, err := json.MarshalIndent(resp, "", "  ")
	if err != nil {
		log.Printf("Error converting to JSON: %v", err)
	} else {
		fmt.Println("Celestia Blob Parameters:")
		fmt.Println(string(jsonData))
	}
}

Passo 8: Executar o código

Antes de executar o seu código, limpe o ambiente e certifique-se de que todas as dependências estão corretamente resolvidas:

executar o comando «mod tidy»

Compile e execute o projeto utilizando:

executa o ficheiro main.go

EfetuargRPC ao Celestia com Go

Visão geral​

É necessária autenticação para Celestia gRPC​

Autenticação básica​

Autenticação x-token​

Iniciar um projeto Go para Celestia gRPC​

Passo 1: Criar um novo diretório de projeto​

Passo 2: Inicializar um módulo Go​

Passo 3: Instalar as dependências gRPC do Protobuf​

Para macOS / Linux​

Para o Windows​

Passo 4: Organizar o diretório do projeto​

Passo 5: Descarregar todas as dependências​

Passo 6: Gerar código Go a partir de ficheiros Proto​

Passo 7: Criar um ficheiro Go principal​

Passo 8: Executar o código​