GetObject gRPC Method

Parameters

object_id

string

REQUIRED

The unique identifier (`ObjectId`) of the object to retrieve from the Sui blockchain.

read_mask

object

Field mask specifying which fields to include in the response.

paths

array

List of object fields to return (e.g., 'object_id', 'version', 'digest', 'owner', 'contents').

Returns

bcs

object

The BCS (Binary Canonical Serialization) representation of the object.

value

string

Base64-encoded BCS-serialized content of the object.

objectId

string

The unique identifier of the object on-chain.

version

string

The version number of the object. Increments with each mutation.

digest

string

Cryptographic hash representing the object's current state.

owner

object

Ownership information of the object.

kind

string

Ownership type (e.g., `AddressOwner`, `Shared`, `Immutable`).

version

string

Object version that defines shared ownership context.

objectType

string

Fully qualified Move type of the object (e.g., module::struct<type_args>).

hasPublicTransfer

boolean

Indicates whether the object supports public transfers without custom logic.

contents

object

Deserialized contents of the object in type-safe form.

name

string

Fully qualified name of the Move struct.

value

string

Base64-encoded raw value of the struct.

previousTransaction

string

Digest of the last transaction that mutated this object.

storageRebate

string

Amount of storage rebate (in MIST) that could be reclaimed by deleting this object.

Request

grpcurl -proto ./sui/rpc/v2beta/ledger_service.proto -H "x-token: YOUR_TOKEN_VALUE" -d '{
  "object_id": "0x27c4fdb3b846aa3ae4a65ef5127a309aa3c1f466671471a806d8912a18b253e8",
  "read_mask": {
    "paths": [
      "bcs",
      "object_id",
      "version",
      "digest",
      "owner",
      "object_type",
      "has_public_transfer",
      "contents",
      "modules",
      "type_origin_table",
      "linkage_table",
      "previous_transaction",
      "storage_rebate"
    ]
  }
}' docs-demo.sui-mainnet.quiknode.pro:9000 sui.rpc.v2beta.LedgerService/GetObject

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"
	"google.golang.org/protobuf/types/known/fieldmaskpb"

	pb "sui-grpc/sui/proto/generated/sui/rpc/v2beta"  // 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"
)

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.NewLedgerServiceClient(conn)

	objectID := "0x27c4fdb3b846aa3ae4a65ef5127a309aa3c1f466671471a806d8912a18b253e8"
	fieldMask := &fieldmaskpb.FieldMask{
		Paths: []string{
			"bcs",
			"object_id",
			"version",
			"digest",
			"owner",
			"object_type",
			"has_public_transfer",
			"contents",
			"modules",
			"type_origin_table",
			"linkage_table",
			"previous_transaction",
			"storage_rebate",
		},
	}

	req := &pb.GetObjectRequest{
		ObjectId: &objectID,
		ReadMask: fieldMask,
	}

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

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

	marshaler := protojson.MarshalOptions{
		UseProtoNames:   true,
		EmitUnpopulated: true,
		Indent:          "  ",
	}

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

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

	formatted, err := json.MarshalIndent(prettyJSON, "", "  ")
	if err != nil {
		log.Fatalf("Failed to format JSON: %v", err)
	}

	fmt.Println(string(formatted))
}

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

// Proto file path
const PROTO_PATH = path.join(__dirname, 'protos/sui/rpc/v2beta/ledger_service.proto');

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

const suiProto = grpc.loadPackageDefinition(packageDefinition) as any;
const LedgerService = suiProto.sui.rpc.v2beta.LedgerService;

// 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';

// Create gRPC client
const client = new LedgerService(endpoint, grpc.credentials.createSsl());

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

// Define the request
const request = {
  object_id: '0x27c4fdb3b846aa3ae4a65ef5127a309aa3c1f466671471a806d8912a18b253e8',
  read_mask: {
    paths: [
      'bcs',
      'object_id',
      'version',
      'digest',
      'owner',
      'object_type',
      'has_public_transfer',
      'contents',
      'modules',
      'type_origin_table',
      'linkage_table',
      'previous_transaction',
      'storage_rebate'
    ],
  },
};

// Decode Buffer/Uint8Array fields into hex strings
function decodeBytes(obj: any): any {
  if (Array.isArray(obj)) {
    return obj.map(decodeBytes);
  } else if (obj && typeof obj === 'object') {
    const result: any = {};
    for (const key in obj) {
      const val = obj[key];
      if (val instanceof Uint8Array || (val?.type === 'Buffer' && Array.isArray(val.data))) {
        const buffer = val instanceof Uint8Array ? val : Buffer.from(val.data);
        result[key] = buffer.toString('hex');
      } else {
        result[key] = decodeBytes(val);
      }
    }
    return result;
  } else {
    return obj;
  }
}

// Make the gRPC call
client.GetObject(request, metadata, (err: any, response: any) => {
  if (err) {
    console.error('gRPC Error:', err);
  } else {
    const decoded = decodeBytes(response);
    console.log('Response:', JSON.stringify(decoded, null, 2));
  }
});

import grpc
import json
from google.protobuf.field_mask_pb2 import FieldMask
from google.protobuf.json_format import MessageToDict
from sui.rpc.v2beta import ledger_service_pb2, ledger_service_pb2_grpc


def get_object():
    # 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 = 'YOUR_TOKEN_HERE';

    channel = grpc.secure_channel(endpoint, grpc.ssl_channel_credentials())
    stub = ledger_service_pb2_grpc.LedgerServiceStub(channel)

    # Specify the object ID you want to retrieve
    # Replace with an actual Sui object ID
    object_id = "0x27c4fdb3b846aa3ae4a65ef5127a309aa3c1f466671471a806d8912a18b253e8"

    # Create a field mask to specify which fields to include in the response
    read_mask = FieldMask(paths=[
        "bcs",
        "object_id",
        "version",
        "digest",
        "owner",
        "object_type",
        "has_public_transfer",
        "contents",
        "modules",
        "type_origin_table",
        "linkage_table",
        "previous_transaction",
        "storage_rebate"
    ])
    
    # Prepare the GetObjectRequest
    request = ledger_service_pb2.GetObjectRequest(
        object_id=object_id,
        read_mask=read_mask
    )

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

    return stub.GetObject(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_object()
        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