With a Quicknode Cosmos endpoint, you can interact with Cosmos chains using either REST or gRPC. The REST API serves JSON over HTTP, making it easy to fetch balances, transactions, and other on-chain data with standard web tools. The gRPC API uses Protocol Buffers over HTTP/2, offering faster, strongly typed requests and streaming support for real-time data. Use REST for quick, human-readable integrations, and gRPC when you need high-performance backend services at scale.

Authentication Required for Cosmos gRPC

To ensure secure access to Cosmos 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.

Authentication for the Cosmos gRPC can be handled in two ways:

1. Autenticação básica
2. 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 + ".cosmos-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 + ".cosmos-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()