GetDatatype gRPC Method

Parameters

package_id

string

REQUIRED

module_name

string

REQUIRED

name

string

REQUIRED

Returns

datatype

object

typeName

string

definingId

string

module

string

name

string

abilities

array

typeParameters

array

isPhantom

boolean

kind

string

fields

array

name

string

position

integer

type

object

type

string

typeName

string

typeParameterInstantiation

array

type

string

typeParameter

integer

typeParameter

integer

Request

grpcurl \
  -import-path . \
  -proto sui/rpc/v2beta2/move_package_service.proto \
  -H "x-token: abcde123456789" \
  -d '{
    "package_id": "0x4897ec4008e4f6500880a547c25a6d4a26807c00ec359b4be24e6322fb2b86b5",
    "module_name": "master",
    "name": "Metadata"
  }' \
  docs-demo.sui-mainnet.quiknode.pro:9000 \
  sui.rpc.v2beta2.MovePackageService/GetDatatype

package main

import (
	"context"
	"crypto/tls"
	"encoding/json"
	"fmt"
	"log"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/protobuf/encoding/protojson"

	pb "sui-grpc/sui/rpc/v2beta2" // 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.sui-mainnet.quiknode.pro/abcde123456789
// endpoint will be: docs-demo.sui-mainnet.quiknode.pro:9000  {9000 is the port number for Sui gRPC}
// token will be : abcde123456789

var (
	token = "YOUR_TOKEN_NUMBER"
	endpoint = "YOUR_QN_ENDPOINT:9000"
)

// Auth structure for x-token
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 true
}

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 := pb.NewMovePackageServiceClient(conn)

	packageID := "0x4897ec4008e4f6500880a547c25a6d4a26807c00ec359b4be24e6322fb2b86b5"
	moduleName := "master"
	datatypeName := "Metadata"

	req := &pb.GetDatatypeRequest{
		PackageId:  &packageID,
		ModuleName: &moduleName,
		Name:       &datatypeName,
	}

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

	resp, err := client.GetDatatype(ctx, req)
	if err != nil {
		log.Fatalf("GetDatatype failed: %v", err)
	}

	// Pretty print the response
	marshaler := protojson.MarshalOptions{
		UseProtoNames:   true,
		EmitUnpopulated: true,
		Indent:          "  ",
	}

	jsonBytes, err := marshaler.Marshal(resp)
	if err != nil {
		log.Fatalf("Failed to marshal: %v", err)
	}

	var pretty map[string]interface{}
	if err := json.Unmarshal(jsonBytes, &pretty); err != nil {
		log.Fatalf("Failed to parse JSON: %v", err)
	}

	out, _ := json.MarshalIndent(pretty, "", "  ")
	fmt.Println(string(out))
}

import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';
import * as path from 'path';

// Configuration
const PROTO_PATH = path.join(__dirname, 'protos/proto/sui/rpc/v2beta2/move_package_service.proto');

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

const endpoint = 'docs-demo.sui-mainnet.quiknode.pro:9000';
const token = 'abcde123456789';

// Load protobuf definitions
const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
  includeDirs: [path.join(__dirname, 'protos/proto')],
});

const proto = grpc.loadPackageDefinition(packageDefinition) as any;
const MovePackageService = proto.sui.rpc.v2beta2.MovePackageService;

// Create secure client
const client = new MovePackageService(endpoint, grpc.credentials.createSsl());

// Add token metadata
const metadata = new grpc.Metadata();
metadata.add('x-token', token);

// Request payload
const request = {
  package_id: '0x2',
  module_name: 'coin',
  name: 'Coin',
};

// Perform gRPC call
client.GetDatatype(request, metadata, (err: grpc.ServiceError | null, response: any) => {
  if (err) {
    console.error('gRPC Error:', {
      code: err.code,
      message: err.message,
      details: err.details,
    });
  } else {
    console.log('GetDatatype Response:');
    console.log(JSON.stringify(response, null, 2));
  }
});

import grpc
import json
from google.protobuf.json_format import MessageToDict
from sui.rpc.v2beta2 import move_package_service_pb2, move_package_service_pb2_grpc


def get_datatype():

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

    endpoint = 'docs-demo.sui-mainnet.quiknode.pro:9000';
    token = 'abcde123456789';

    channel = grpc.secure_channel(endpoint, grpc.ssl_channel_credentials())
    stub = move_package_service_pb2_grpc.MovePackageServiceStub(channel)

    package_id = "0x2"
    module_name = "coin"
    name = "Coin"

    request = move_package_service_pb2.GetDatatypeRequest(
        package_id=package_id,
        module_name=module_name,
        name=name
    )

    metadata = [("x-token", token)]

    return stub.GetDatatype(request, metadata=metadata)


def parse_response_to_json(response):
    return json.dumps(
        MessageToDict(response, preserving_proto_field_name=True),
        indent=2
    )


def main():
    try:
        response = get_datatype()
        print(parse_response_to_json(response))
    except grpc.RpcError as e:
        print(f"{e.code().name}: {e.details()}")

if __name__ == "__main__":
    main()

Don't have an account yet?

Create your QuickNode endpoint in seconds and start building

Get started for free

GetDatatype gRPC Method

Loading...

Parameters

Returns